diff --git a/3rdparty/ffmpeg/make.bat b/3rdparty/ffmpeg/make.bat
index 6c965c57cb..f4f9592683 100644
--- a/3rdparty/ffmpeg/make.bat
+++ b/3rdparty/ffmpeg/make.bat
@@ -1,2 +1,3 @@
+rem gcc -Wall -shared -o opencv_ffmpeg.dll -O3 -x c++ -I../include -I../include/ffmpeg_ -I../../modules/highgui/src ffopencv.c -L../lib -lavformat -lavcodec -lavdevice -lswscale -lavutil -lwsock32 -lpthreadG�E2
 gcc -Wall -shared -o opencv_ffmpeg.dll -O2 -x c++ -I../include -I../include/ffmpeg_ -I../../modules/highgui/src ffopencv.c -L../lib -lavformat -lavcodec -lavdevice -lswscale -lavutil -lwsock32
 set path=c:\apps\mingw64\bin;%path% & gcc -Wall -shared -o opencv_ffmpeg_64.dll -O2 -x c++ -I../include -I../include/ffmpeg_ -I../../modules/highgui/src ffopencv.c -L../lib -lavformat64 -lavcodec64 -lavdevice64 -lswscale64 -lavutil64 -lavcore64 -lwsock32
\ No newline at end of file
diff --git a/3rdparty/lib/armeabi-v7a/libnative_camera_r2.2.2.so b/3rdparty/lib/armeabi-v7a/libnative_camera_r2.2.2.so
new file mode 100644
index 0000000000..b36b97a36a
Binary files /dev/null and b/3rdparty/lib/armeabi-v7a/libnative_camera_r2.2.2.so differ
diff --git a/3rdparty/lib/armeabi-v7a/libnative_camera_r2.3.3.so b/3rdparty/lib/armeabi-v7a/libnative_camera_r2.3.3.so
new file mode 100644
index 0000000000..28c567672b
Binary files /dev/null and b/3rdparty/lib/armeabi-v7a/libnative_camera_r2.3.3.so differ
diff --git a/3rdparty/lib/armeabi/libnative_camera_r2.2.2.so b/3rdparty/lib/armeabi/libnative_camera_r2.2.2.so
new file mode 100755
index 0000000000..5209ce29d0
Binary files /dev/null and b/3rdparty/lib/armeabi/libnative_camera_r2.2.2.so differ
diff --git a/3rdparty/lib/armeabi/libnative_camera_r2.3.3.so b/3rdparty/lib/armeabi/libnative_camera_r2.3.3.so
new file mode 100755
index 0000000000..af006de71b
Binary files /dev/null and b/3rdparty/lib/armeabi/libnative_camera_r2.3.3.so differ
diff --git a/3rdparty/lib/libnative_camera_r2.2.2.so b/3rdparty/lib/libnative_camera_r2.2.2.so
deleted file mode 100644
index 0866e4348a..0000000000
Binary files a/3rdparty/lib/libnative_camera_r2.2.2.so and /dev/null differ
diff --git a/3rdparty/lib/libnative_camera_r2.3.3.so b/3rdparty/lib/libnative_camera_r2.3.3.so
deleted file mode 100644
index 54e6c09b26..0000000000
Binary files a/3rdparty/lib/libnative_camera_r2.3.3.so and /dev/null differ
diff --git a/3rdparty/libjasper/CMakeLists.txt b/3rdparty/libjasper/CMakeLists.txt
index 4a5a2faf4e..a381dbedf9 100644
--- a/3rdparty/libjasper/CMakeLists.txt
+++ b/3rdparty/libjasper/CMakeLists.txt
@@ -45,7 +45,7 @@ set_target_properties(${the_target}
 	PROPERTIES
 	OUTPUT_NAME "${the_target}"
 	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/lib"
+	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
 	)
 	
 if(ENABLE_SOLUTION_FOLDERS)
@@ -54,5 +54,5 @@ endif()
     
 if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
+	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 endif()
diff --git a/3rdparty/libjpeg/CMakeLists.txt b/3rdparty/libjpeg/CMakeLists.txt
index c78bfc369c..b432701455 100644
--- a/3rdparty/libjpeg/CMakeLists.txt
+++ b/3rdparty/libjpeg/CMakeLists.txt
@@ -37,7 +37,7 @@ endif()
 set_target_properties(${the_target}
 	PROPERTIES OUTPUT_NAME "${the_target}"
 	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty/lib
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}
 	)
 	
 if(ENABLE_SOLUTION_FOLDERS)
@@ -46,5 +46,5 @@ endif()
     
 if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
+	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 endif()
diff --git a/3rdparty/libpng/CMakeLists.txt b/3rdparty/libpng/CMakeLists.txt
index 4eda135002..e7e91da2ab 100644
--- a/3rdparty/libpng/CMakeLists.txt
+++ b/3rdparty/libpng/CMakeLists.txt
@@ -38,7 +38,7 @@ endif()
 set_target_properties(${the_target}
 	PROPERTIES OUTPUT_NAME "${the_target}"
 	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/lib"
+	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
 	)
 	
 if(ENABLE_SOLUTION_FOLDERS)
@@ -47,5 +47,5 @@ endif()
     
 if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
+	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 endif()
diff --git a/3rdparty/libtiff/CMakeLists.txt b/3rdparty/libtiff/CMakeLists.txt
index 899ff987fd..924c22e8a5 100644
--- a/3rdparty/libtiff/CMakeLists.txt
+++ b/3rdparty/libtiff/CMakeLists.txt
@@ -92,7 +92,7 @@ set_target_properties(${the_target}
 	PROPERTIES
 	OUTPUT_NAME "${the_target}"
 	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/lib/"
+	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
 	)
 	
 if(ENABLE_SOLUTION_FOLDERS)
@@ -101,5 +101,5 @@ endif()
 
 if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
+	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 endif()
diff --git a/3rdparty/libtiff/tif_color.c b/3rdparty/libtiff/tif_color.c
index 02eb346b06..da140030c8 100644
--- a/3rdparty/libtiff/tif_color.c
+++ b/3rdparty/libtiff/tif_color.c
@@ -1,4 +1,4 @@
-/* $Id: tif_color.c,v 1.12.2.1 2010-06-08 18:50:41 bfriesen Exp $ */
+/* $Id: tif_color.c,v 1.12.2.2 2010-12-14 02:23:09 faxguy Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -183,13 +183,18 @@ void
 TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr,
 	       uint32 *r, uint32 *g, uint32 *b)
 {
+	int32 i;
+
 	/* XXX: Only 8-bit YCbCr input supported for now */
 	Y = HICLAMP(Y, 255), Cb = CLAMP(Cb, 0, 255), Cr = CLAMP(Cr, 0, 255);
 
-	*r = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]];
-	*g = ycbcr->clamptab[ycbcr->Y_tab[Y]
-	    + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT)];
-	*b = ycbcr->clamptab[ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]];
+	i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr];
+	*r = CLAMP(i, 0, 255);
+	i = ycbcr->Y_tab[Y]
+	    + (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
+	*g = CLAMP(i, 0, 255);
+	i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb];
+	*b = CLAMP(i, 0, 255);
 }
 
 /*
diff --git a/3rdparty/libtiff/tif_dir.c b/3rdparty/libtiff/tif_dir.c
index ac44b381f8..335ee58f41 100644
--- a/3rdparty/libtiff/tif_dir.c
+++ b/3rdparty/libtiff/tif_dir.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dir.c,v 1.75.2.5 2010-06-09 21:15:27 bfriesen Exp $ */
+/* $Id: tif_dir.c,v 1.75.2.6 2010-07-02 09:49:23 dron Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -163,7 +163,9 @@ _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
 		 * work in with its normal work.
 		 */
 		if (tif->tif_flags & TIFF_SWAB) {
-			if (td->td_bitspersample == 16)
+			if (td->td_bitspersample == 8)
+				tif->tif_postdecode = _TIFFNoPostDecode;
+			else if (td->td_bitspersample == 16)
 				tif->tif_postdecode = _TIFFSwab16BitData;
 			else if (td->td_bitspersample == 24)
 				tif->tif_postdecode = _TIFFSwab24BitData;
diff --git a/3rdparty/libtiff/tif_dirread.c b/3rdparty/libtiff/tif_dirread.c
index 0fb205beb5..a9da79769d 100644
--- a/3rdparty/libtiff/tif_dirread.c
+++ b/3rdparty/libtiff/tif_dirread.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dirread.c,v 1.92.2.9 2010-06-14 00:21:46 fwarmerdam Exp $ */
+/* $Id: tif_dirread.c,v 1.92.2.15 2010-12-31 16:12:40 olivier Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -54,7 +54,7 @@ static	float TIFFFetchRational(TIFF*, TIFFDirEntry*);
 static	int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*);
 static	int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, uint16*);
 static	int TIFFFetchPerSampleLongs(TIFF*, TIFFDirEntry*, uint32*);
-static	int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);
+static	int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*, double*);
 static	int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
 static	int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
 static	int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
@@ -83,6 +83,7 @@ TIFFReadDirectory(TIFF* tif)
 	const TIFFFieldInfo* fip;
 	size_t fix;
 	uint16 dircount;
+	uint16 previous_tag = 0;
 	int diroutoforderwarning = 0, compressionknown = 0;
 	int haveunknowntags = 0;
 
@@ -105,7 +106,20 @@ TIFFReadDirectory(TIFF* tif)
 			     tif->tif_name, tif->tif_nextdiroff);
 		return 0;
 	}
-
+	{
+		TIFFDirEntry* ma;
+		uint16 mb;
+		for (ma=dir, mb=0; mb<dircount; ma++, mb++)
+		{
+			TIFFDirEntry* na;
+			uint16 nb;
+			for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++)
+			{
+				if (ma->tdir_tag==na->tdir_tag)
+					na->tdir_tag=IGNORE;
+			}
+		}
+	}
 	tif->tif_flags &= ~TIFF_BEENWRITING;	/* reset before new dir */
 	/*
 	 * Setup default value and then make a pass over
@@ -163,23 +177,24 @@ TIFFReadDirectory(TIFF* tif)
 
 		if (dp->tdir_tag == IGNORE)
 			continue;
-		if (fix >= tif->tif_nfields)
-			fix = 0;
 
 		/*
 		 * Silicon Beach (at least) writes unordered
 		 * directory tags (violating the spec).  Handle
 		 * it here, but be obnoxious (maybe they'll fix it?).
 		 */
-		if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) {
+		if (dp->tdir_tag < previous_tag) {
 			if (!diroutoforderwarning) {
 				TIFFWarningExt(tif->tif_clientdata, module,
 	"%s: invalid TIFF directory; tags are not sorted in ascending order",
 					    tif->tif_name);
 				diroutoforderwarning = 1;
 			}
-			fix = 0;			/* O(n^2) */
 		}
+		previous_tag = dp->tdir_tag;
+		if (fix >= tif->tif_nfields ||
+		    dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag)
+			fix = 0;			/* O(n^2) */
 		while (fix < tif->tif_nfields &&
 		    tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
 			fix++;
@@ -465,11 +480,18 @@ TIFFReadDirectory(TIFF* tif)
 			}
 			break;
 		case TIFFTAG_SMINSAMPLEVALUE:
+			{
+				double minv = 0.0, maxv = 0.0;
+				if (!TIFFFetchPerSampleAnys(tif, dp, &minv, &maxv) ||
+				    !TIFFSetField(tif, dp->tdir_tag, minv))
+					goto bad;
+			}
+			break;
 		case TIFFTAG_SMAXSAMPLEVALUE:
 			{
-				double dv = 0.0;
-				if (!TIFFFetchPerSampleAnys(tif, dp, &dv) ||
-				    !TIFFSetField(tif, dp->tdir_tag, dv))
+				double minv = 0.0, maxv = 0.0;
+				if (!TIFFFetchPerSampleAnys(tif, dp, &minv, &maxv) ||
+				    !TIFFSetField(tif, dp->tdir_tag, maxv))
 					goto bad;
 			}
 			break;
@@ -593,8 +615,7 @@ TIFFReadDirectory(TIFF* tif)
 		}
 		if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
 		{
-			if ((td->td_photometric==PHOTOMETRIC_RGB)
-			    || (td->td_photometric==PHOTOMETRIC_YCBCR))
+			if (td->td_photometric==PHOTOMETRIC_RGB)
 			{
 				TIFFWarningExt(tif->tif_clientdata,
 					       "TIFFReadDirectory",
@@ -603,13 +624,22 @@ TIFFReadDirectory(TIFF* tif)
 				if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
 					goto bad;
 			}
-			else if ((td->td_photometric==PHOTOMETRIC_MINISWHITE)
-				 || (td->td_photometric==PHOTOMETRIC_MINISBLACK))
+			if (td->td_photometric==PHOTOMETRIC_YCBCR)
 			{
 				TIFFWarningExt(tif->tif_clientdata,
 					       "TIFFReadDirectory",
 				"SamplesPerPixel tag is missing, "
-				"assuming correct SamplesPerPixel value is 1");
+				"applying correct SamplesPerPixel value of 3");
+				if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
+					goto bad;
+			}
+			else if ((td->td_photometric==PHOTOMETRIC_MINISWHITE)
+				 || (td->td_photometric==PHOTOMETRIC_MINISBLACK))
+			{
+				/*
+				 * SamplesPerPixel tag is missing, but is not required
+				 * by spec.  Assume correct SamplesPerPixel value of 1.
+				 */
 				if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1))
 					goto bad;
 			}
@@ -620,8 +650,14 @@ TIFFReadDirectory(TIFF* tif)
 	 */
 	if (td->td_photometric == PHOTOMETRIC_PALETTE &&
 	    !TIFFFieldSet(tif, FIELD_COLORMAP)) {
-		MissingRequired(tif, "Colormap");
-		goto bad;
+		if ( tif->tif_dir.td_bitspersample>=8 && tif->tif_dir.td_samplesperpixel==3)
+			tif->tif_dir.td_photometric = PHOTOMETRIC_RGB;
+		else if (tif->tif_dir.td_bitspersample>=8)
+			tif->tif_dir.td_photometric = PHOTOMETRIC_MINISBLACK;
+		else {
+			MissingRequired(tif, "Colormap");
+			goto bad;
+		}
 	}
 	/*
 	 * OJPEG hack:
@@ -1086,6 +1122,7 @@ CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
 	"incorrect count for field \"%s\" (%u, expecting %u); tag trimmed",
 		    _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
 		    dir->tdir_count, count);
+		dir->tdir_count = count;
 		return (1);
 	}
 	return (1);
@@ -1413,14 +1450,14 @@ TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
 		case TIFF_BYTE:
 		case TIFF_SBYTE:
 			{
-			uint8 v[4];
+            uint8 v[4]={0,0,0,0};
 			return TIFFFetchByteArray(tif, dir, v)
 				&& TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
 			}
 		case TIFF_SHORT:
 		case TIFF_SSHORT:
 			{
-			uint16 v[2]={0,0};
+            uint16 v[2]={0,0};
 			return TIFFFetchShortArray(tif, dir, v)
 				&& TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
 			}
@@ -1822,11 +1859,11 @@ TIFFFetchPerSampleLongs(TIFF* tif, TIFFDirEntry* dir, uint32* pl)
 }
 
 /*
- * Fetch samples/pixel ANY values for the specified tag and verify that all
- * values are the same.
+ * Fetch samples/pixel ANY values for the specified tag and returns their min
+ * and max.
  */
 static int
-TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
+TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* minv, double* maxv)
 {
     uint16 samples = tif->tif_dir.td_samplesperpixel;
     int status = 0;
@@ -1844,17 +1881,16 @@ TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
             if( samples < check_count )
                 check_count = samples;
 
+            *minv = *maxv = v[0];
             for (i = 1; i < check_count; i++)
-                if (v[i] != v[0]) {
-			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
-		"Cannot handle different per-sample values for field \"%s\"",
-			_TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
-			goto bad;
-                }
-            *pl = v[0];
+            {
+                if (v[i] < *minv)
+                    *minv = v[i];
+                if (v[i] > *maxv)
+                    *maxv = v[i];
+            }
             status = 1;
         }
-      bad:
         if (v && v != buf)
             _TIFFfree(v);
     }
diff --git a/3rdparty/libtiff/tif_dirwrite.c b/3rdparty/libtiff/tif_dirwrite.c
index 8d308c4292..6f298399c2 100644
--- a/3rdparty/libtiff/tif_dirwrite.c
+++ b/3rdparty/libtiff/tif_dirwrite.c
@@ -1,4 +1,4 @@
-/* $Id: tif_dirwrite.c,v 1.37.2.7 2010-06-08 18:50:42 bfriesen Exp $ */
+/* $Id: tif_dirwrite.c,v 1.37.2.9 2011-02-25 15:28:30 dron Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -42,6 +42,7 @@ extern	void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*);
 static	int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*);
 static	void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32);
 static	void TIFFSetupShort(TIFF*, ttag_t, TIFFDirEntry*, uint16);
+static	int TIFFSetupBytePair(TIFF*, ttag_t, TIFFDirEntry*);
 static	int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*);
 static	int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*);
 static	int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*);
@@ -291,12 +292,6 @@ _TIFFWriteDirectory(TIFF* tif, int done)
 			    _TIFFSampleToTagType(tif), fip->field_tag, dir))
 				goto bad;
 			break;
-		case FIELD_PAGENUMBER:
-		case FIELD_HALFTONEHINTS:
-		case FIELD_YCBCRSUBSAMPLING:
-			if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
-				goto bad;
-			break;
 		case FIELD_INKNAMES:
 			if (!TIFFWriteInkNames(tif, dir))
 				goto bad;
@@ -336,12 +331,22 @@ _TIFFWriteDirectory(TIFF* tif, int done)
 			}
 			break;
 		default:
-			/* XXX: Should be fixed and removed. */
-			if (fip->field_tag == TIFFTAG_DOTRANGE) {
-				if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
-					goto bad;
-			}
-			else if (!TIFFWriteNormalTag(tif, dir, fip))
+			/*
+			 * XXX: Should be fixed and removed. See comments
+			 * related to these tags in tif_dir.c.
+			 */
+			if (fip->field_tag == TIFFTAG_PAGENUMBER
+			    || fip->field_tag == TIFFTAG_HALFTONEHINTS
+			    || fip->field_tag == TIFFTAG_YCBCRSUBSAMPLING
+			    || fip->field_tag == TIFFTAG_DOTRANGE) {
+				if (fip->field_type == TIFF_BYTE) {
+					if (!TIFFSetupBytePair(tif, fip->field_tag, dir))
+						goto bad;
+				} else if (fip->field_type == TIFF_SHORT) {
+					if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
+						goto bad;
+				}
+			} else if (!TIFFWriteNormalTag(tif, dir, fip))
 				goto bad;
 			break;
 		}
@@ -875,6 +880,23 @@ TIFFWritePerSampleAnys(TIFF* tif,
 }
 #undef NITEMS
 
+/*
+ * Setup a pair of bytes that are returned by
+ * value, rather than as a reference to an array.
+ */
+static int
+TIFFSetupBytePair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
+{
+	char v[2];
+
+	TIFFGetField(tif, tag, &v[0], &v[1]);
+
+	dir->tdir_tag = (uint16) tag;
+	dir->tdir_type = (uint16) TIFF_BYTE;
+	dir->tdir_count = 2;
+	return (TIFFWriteByteArray(tif, dir, v));
+}
+
 /*
  * Setup a pair of shorts that are returned by
  * value, rather than as a reference to an array.
@@ -1019,7 +1041,7 @@ TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
 			while (fv < 1L<<(31-3) && den < 1L<<(31-3))
 				fv *= 1<<3, den *= 1L<<3;
 		}
-		t[2*i+0] = (uint32) (sign * (fv + 0.5));
+		t[2*i+0] = (uint32) (sign * (int32)(fv + 0.5));
 		t[2*i+1] = den;
 	}
 	status = TIFFWriteData(tif, dir, (char *)t);
diff --git a/3rdparty/libtiff/tif_fax3.h b/3rdparty/libtiff/tif_fax3.h
index 40718bcfa7..d7d7723a6a 100644
--- a/3rdparty/libtiff/tif_fax3.h
+++ b/3rdparty/libtiff/tif_fax3.h
@@ -1,4 +1,4 @@
-/* $Id: tif_fax3.h,v 1.5.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
+/* $Id: tif_fax3.h,v 1.5.2.3 2011-03-10 20:22:33 fwarmerdam Exp $ */
 
 /*
  * Copyright (c) 1990-1997 Sam Leffler
@@ -478,6 +478,12 @@ done1d:									\
 	    break;							\
 	case S_VL:							\
 	    CHECK_b1;							\
+	    if (b1 <= (int) (a0 + TabEnt->Param)) {			\
+		if (b1 < (int) (a0 + TabEnt->Param) || pa != thisrun) {	\
+		    unexpected("VL", a0);				\
+		    goto eol2d;						\
+		}							\
+	    }								\
 	    SETVALUE(b1 - a0 - TabEnt->Param);				\
 	    b1 -= *--pb;						\
 	    break;							\
diff --git a/3rdparty/libtiff/tif_getimage.c b/3rdparty/libtiff/tif_getimage.c
index 38455fbc07..11d59e06e6 100644
--- a/3rdparty/libtiff/tif_getimage.c
+++ b/3rdparty/libtiff/tif_getimage.c
@@ -1,4 +1,4 @@
-/* $Id: tif_getimage.c,v 1.63.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
+/* $Id: tif_getimage.c,v 1.63.2.6 2010-07-02 13:38:27 dron Exp $ */
 
 /*
  * Copyright (c) 1991-1997 Sam Leffler
@@ -1846,6 +1846,7 @@ DECLAREContigPutFunc(putcontig8bitYCbCr41tile)
 DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
 {
 	uint32* cp2;
+	int32 incr = 2*toskew+w;
 	(void) y;
 	fromskew = (fromskew / 2) * 6;
 	cp2 = cp+w+toskew;
@@ -1872,8 +1873,8 @@ DECLAREContigPutFunc(putcontig8bitYCbCr22tile)
 			cp2 ++ ;
 			pp += 6;
 		}
-		cp += toskew*2+w;
-		cp2 += toskew*2+w;
+		cp += incr;
+		cp2 += incr;
 		pp += fromskew;
 		h-=2;
 	}
@@ -1939,6 +1940,7 @@ DECLAREContigPutFunc(putcontig8bitYCbCr21tile)
 DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
 {
 	uint32* cp2;
+	int32 incr = 2*toskew+w;
 	(void) y;
 	fromskew = (fromskew / 2) * 4;
 	cp2 = cp+w+toskew;
@@ -1953,8 +1955,8 @@ DECLAREContigPutFunc(putcontig8bitYCbCr12tile)
 			cp2 ++;
 			pp += 4;
 		} while (--x);
-		cp += toskew*2+w;
-		cp2 += toskew*2+w;
+		cp += incr;
+		cp2 += incr;
 		pp += fromskew;
 		h-=2;
 	}
@@ -2397,7 +2399,7 @@ PickContigCase(TIFFRGBAImage* img)
 			}
 			break;
 		case PHOTOMETRIC_YCBCR:
-			if (img->bitspersample == 8)
+			if ((img->bitspersample==8) && (img->samplesperpixel==3))
 			{
 				if (initYCbCrConversion(img)!=0)
 				{
diff --git a/3rdparty/libtiff/tif_jpeg.c b/3rdparty/libtiff/tif_jpeg.c
index a967827e74..7fc3e95929 100644
--- a/3rdparty/libtiff/tif_jpeg.c
+++ b/3rdparty/libtiff/tif_jpeg.c
@@ -1,4 +1,4 @@
-/* $Id: tif_jpeg.c,v 1.50.2.9 2010-06-14 02:47:16 fwarmerdam Exp $ */
+/* $Id: tif_jpeg.c,v 1.50.2.17 2011-01-04 02:51:17 faxguy Exp $ */
 
 /*
  * Copyright (c) 1994-1997 Sam Leffler
@@ -988,8 +988,15 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
 	tsize_t nrows;
 	(void) s;
 
-	/* data is expected to be read in multiples of a scanline */
-	if ( (nrows = sp->cinfo.d.image_height) ) {
+    nrows = cc / sp->bytesperline;
+    if (cc % sp->bytesperline)
+		TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read");
+
+    if( nrows > (int) sp->cinfo.d.image_height )
+        nrows = sp->cinfo.d.image_height;
+
+    /* data is expected to be read in multiples of a scanline */
+    if (nrows) {
 		/* Cb,Cr both have sampling factors 1, so this is correct */
 		JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;            
 		int samples_per_clump = sp->samplesperclump;
@@ -1064,7 +1071,7 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
 					}
 				}
 				else
-				{         // 12-bit
+				{         /* 12-bit  */
 					int value_pairs = (sp->cinfo.d.output_width
 					    * sp->cinfo.d.num_components) / 2;
 					int iPair;
@@ -1087,8 +1094,7 @@ JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
 			 * TODO: resolve this */
 			buf += sp->bytesperline;
 			cc -= sp->bytesperline;
-			nrows -= sp->v_sampling;
-		} while (nrows > 0);
+		} while (--nrows > 0);
 
 #ifdef JPEG_LIB_MK1
 		_TIFFfree(tmpbuf);
@@ -1352,8 +1358,15 @@ JPEGPreEncode(TIFF* tif, tsample_t s)
 			sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
 			sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
 		} else {
-			sp->cinfo.c.in_color_space = JCS_UNKNOWN;
-			if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
+			if ((td->td_photometric == PHOTOMETRIC_MINISWHITE || td->td_photometric == PHOTOMETRIC_MINISBLACK) && td->td_samplesperpixel == 1)
+				sp->cinfo.c.in_color_space = JCS_GRAYSCALE;
+			else if (td->td_photometric == PHOTOMETRIC_RGB)
+				sp->cinfo.c.in_color_space = JCS_RGB;
+			else if (td->td_photometric == PHOTOMETRIC_SEPARATED && td->td_samplesperpixel == 4)
+				sp->cinfo.c.in_color_space = JCS_CMYK;
+			else
+				sp->cinfo.c.in_color_space = JCS_UNKNOWN;
+			if (!TIFFjpeg_set_colorspace(sp, sp->cinfo.c.in_color_space))
 				return (0);
 			/* jpeg_set_colorspace set all sampling factors to 1 */
 		}
@@ -1523,7 +1536,7 @@ JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
 			sp->scancount = 0;
 		}
 		tif->tif_row += sp->v_sampling;
-		buf += sp->bytesperline;
+		buf += bytesperclumpline;
 		nrows -= sp->v_sampling;
 	}
 	return (1);
diff --git a/3rdparty/libtiff/tif_ojpeg.c b/3rdparty/libtiff/tif_ojpeg.c
index 9ae856cfde..9eba6d5c6a 100644
--- a/3rdparty/libtiff/tif_ojpeg.c
+++ b/3rdparty/libtiff/tif_ojpeg.c
@@ -1,4 +1,4 @@
-/* $Id: tif_ojpeg.c,v 1.24.2.6 2010-06-08 23:29:51 bfriesen Exp $ */
+/* $Id: tif_ojpeg.c,v 1.24.2.8 2010-12-11 21:25:04 faxguy Exp $ */
 
 /* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0
    specification is now totally obsolete and deprecated for new applications and
@@ -1537,7 +1537,6 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
 		OJPEGReadSkip(sp,4);
 	else
 	{
-		/* TODO: probably best to also add check on allowed upper bound, especially x, may cause buffer overflow otherwise i think */
 		/* Y: Number of lines */
 		if (OJPEGReadWord(sp,&p)==0)
 			return(0);
@@ -1555,6 +1554,11 @@ OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
 			TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
 			return(0);
 		}
+		if ((uint32)p>sp->strile_width)
+		{
+			TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width");
+			return(0);
+		}
 		sp->sof_x=p;
 	}
 	/* Nf: Number of image components in frame */
@@ -1918,8 +1922,14 @@ OJPEGReadBufferFill(OJPEGState* sp)
 					{
 						if (sp->in_buffer_file_pos>=sp->file_size)
 							sp->in_buffer_file_pos=0;
+						else if (sp->tif->tif_dir.td_stripbytecount==NULL)
+							sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
 						else
 						{
+							if (sp->tif->tif_dir.td_stripbytecount == 0) {
+								TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing");
+								return(0);
+							}
 							sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];  
 							if (sp->in_buffer_file_togo==0)
 								sp->in_buffer_file_pos=0;
diff --git a/3rdparty/libtiff/tif_open.c b/3rdparty/libtiff/tif_open.c
index 3b3b2ce67b..4ad04d2cf9 100644
--- a/3rdparty/libtiff/tif_open.c
+++ b/3rdparty/libtiff/tif_open.c
@@ -1,4 +1,4 @@
-/* $Id: tif_open.c,v 1.33.2.1 2010-06-08 18:50:42 bfriesen Exp $ */
+/* $Id: tif_open.c,v 1.33.2.2 2010-12-06 16:54:22 faxguy Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -304,7 +304,7 @@ TIFFClientOpen(
 	/*
 	 * Read in TIFF header.
 	 */
-	if (tif->tif_mode & O_TRUNC ||
+	if ((m & O_TRUNC) ||
 	    !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeader))) {
 		if (tif->tif_mode == O_RDONLY) {
 			TIFFErrorExt(tif->tif_clientdata, name,
diff --git a/3rdparty/libtiff/tif_print.c b/3rdparty/libtiff/tif_print.c
index d9e4435c50..ce563cbe06 100644
--- a/3rdparty/libtiff/tif_print.c
+++ b/3rdparty/libtiff/tif_print.c
@@ -1,4 +1,4 @@
-/* $Id: tif_print.c,v 1.36.2.4 2010-06-08 18:50:42 bfriesen Exp $ */
+/* $Id: tif_print.c,v 1.36.2.5 2010-07-06 14:05:30 dron Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -115,8 +115,6 @@ static int
 _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
 		      uint32 value_count, void *raw_data)
 {
-	//TIFFDirectory *td = &tif->tif_dir;
-
 	switch (tag)
 	{
 		case TIFFTAG_INKSET:
@@ -132,10 +130,6 @@ _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
 					break;
 			}
 			return 1;
-		case TIFFTAG_DOTRANGE:
-			fprintf(fd, "  Dot Range: %u-%u\n",
-				((uint16*)raw_data)[0], ((uint16*)raw_data)[1]);
-			return 1;
 		case TIFFTAG_WHITEPOINT:
 			fprintf(fd, "  White Point: %g-%g\n",
 				((float *)raw_data)[0], ((float *)raw_data)[1]);			return 1;
diff --git a/3rdparty/libtiff/tif_strip.c b/3rdparty/libtiff/tif_strip.c
index 63dec6bdac..0542d004fa 100644
--- a/3rdparty/libtiff/tif_strip.c
+++ b/3rdparty/libtiff/tif_strip.c
@@ -1,4 +1,4 @@
-/* $Id: tif_strip.c,v 1.19.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
+/* $Id: tif_strip.c,v 1.19.2.3 2010-12-15 00:50:30 faxguy Exp $ */
 
 /*
  * Copyright (c) 1991-1997 Sam Leffler
@@ -124,9 +124,9 @@ TIFFVStripSize(TIFF* tif, uint32 nrows)
 		uint16 ycbcrsubsampling[2];
 		tsize_t w, scanline, samplingarea;
 
-		TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
-			      ycbcrsubsampling + 0,
-			      ycbcrsubsampling + 1 );
+		TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
+				      ycbcrsubsampling + 0,
+				      ycbcrsubsampling + 1);
 
 		samplingarea = ycbcrsubsampling[0]*ycbcrsubsampling[1];
 		if (samplingarea == 0) {
@@ -234,27 +234,23 @@ TIFFScanlineSize(TIFF* tif)
 		    && !isUpSampled(tif)) {
 			uint16 ycbcrsubsampling[2];
 
-			TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING,
-				     ycbcrsubsampling + 0,
-				     ycbcrsubsampling + 1);
+			TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
+					      ycbcrsubsampling + 0,
+					      ycbcrsubsampling + 1);
 
-			if (ycbcrsubsampling[0] == 0) {
+			if (ycbcrsubsampling[0]*ycbcrsubsampling[1] == 0) {
 				TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 					     "Invalid YCbCr subsampling");
 				return 0;
 			}
 
-			scanline = TIFFroundup(td->td_imagewidth,
+			/* number of sample clumps per line */
+			scanline = TIFFhowmany(td->td_imagewidth,
 					       ycbcrsubsampling[0]);
-			scanline = TIFFhowmany8(multiply(tif, scanline,
-							 td->td_bitspersample,
-							 "TIFFScanlineSize"));
-			return ((tsize_t)
-				summarize(tif, scanline,
-					  multiply(tif, 2,
-						scanline / ycbcrsubsampling[0],
-						"TIFFVStripSize"),
-					  "TIFFVStripSize"));
+			/* number of samples per line */
+			scanline = multiply(tif, scanline,
+					    ycbcrsubsampling[0]*ycbcrsubsampling[1] + 2,
+					    "TIFFScanlineSize");
 		} else {
 			scanline = multiply(tif, td->td_imagewidth,
 					    td->td_samplesperpixel,
@@ -308,9 +304,9 @@ TIFFNewScanlineSize(TIFF* tif)
 		    && !isUpSampled(tif)) {
 			uint16 ycbcrsubsampling[2];
 
-			TIFFGetField(tif, TIFFTAG_YCBCRSUBSAMPLING,
-				     ycbcrsubsampling + 0,
-				     ycbcrsubsampling + 1);
+			TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
+					      ycbcrsubsampling + 0,
+					      ycbcrsubsampling + 1);
 
 			if (ycbcrsubsampling[0]*ycbcrsubsampling[1] == 0) {
 				TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
diff --git a/3rdparty/libtiff/tif_thunder.c b/3rdparty/libtiff/tif_thunder.c
index 8e7a125841..62e4bc75ed 100644
--- a/3rdparty/libtiff/tif_thunder.c
+++ b/3rdparty/libtiff/tif_thunder.c
@@ -1,4 +1,4 @@
-/* $Id: tif_thunder.c,v 1.5.2.1 2010-06-08 18:50:43 bfriesen Exp $ */
+/* $Id: tif_thunder.c,v 1.5.2.2 2011-03-21 16:01:28 fwarmerdam Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -25,6 +25,7 @@
  */
 
 #include "tiffiop.h"
+#include <assert.h>
 #ifdef THUNDER_SUPPORT
 /*
  * TIFF Library.
@@ -55,12 +56,32 @@
 static const int twobitdeltas[4] = { 0, 1, 0, -1 };
 static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 };
 
-#define	SETPIXEL(op, v) { \
-	lastpixel = (v) & 0xf; \
-	if (npixels++ & 1) \
-	    *op++ |= lastpixel; \
-	else \
+#define	SETPIXEL(op, v) {                     \
+	lastpixel = (v) & 0xf;                \
+        if ( npixels < maxpixels )         \
+        {                                     \
+	  if (npixels++ & 1)                  \
+	    *op++ |= lastpixel;               \
+	  else                                \
 	    op[0] = (tidataval_t) (lastpixel << 4); \
+        }                                     \
+}
+
+static int
+ThunderSetupDecode(TIFF* tif)
+{
+	static const char module[] = "ThunderSetupDecode";
+
+        if( tif->tif_dir.td_bitspersample != 4 )
+        {
+                TIFFErrorExt(tif->tif_clientdata, module,
+                             "Wrong bitspersample value (%d), Thunder decoder only supports 4bits per sample.",
+                             (int) tif->tif_dir.td_bitspersample );
+                return 0;
+        }
+        
+
+	return (1);
 }
 
 static int
@@ -142,7 +163,8 @@ ThunderDecodeRow(TIFF* tif, tidata_t buf, tsize_t occ, tsample_t s)
 		occ -= tif->tif_scanlinesize;
 		row += tif->tif_scanlinesize;
 	}
-	return (1);
+
+        return (1);
 }
 
 int
@@ -151,6 +173,7 @@ TIFFInitThunderScan(TIFF* tif, int scheme)
 	(void) scheme;
 	tif->tif_decoderow = ThunderDecodeRow;
 	tif->tif_decodestrip = ThunderDecodeRow;
+        tif->tif_setupdecode = ThunderSetupDecode;
 	return (1);
 }
 #endif /* THUNDER_SUPPORT */
@@ -163,3 +186,4 @@ TIFFInitThunderScan(TIFF* tif, int scheme)
  * fill-column: 78
  * End:
  */
+
diff --git a/3rdparty/libtiff/tiffiop.h b/3rdparty/libtiff/tiffiop.h
index a064039f6b..f65f8550ea 100644
--- a/3rdparty/libtiff/tiffiop.h
+++ b/3rdparty/libtiff/tiffiop.h
@@ -1,4 +1,4 @@
-/* $Id: tiffiop.h,v 1.51.2.6 2010-06-12 02:55:16 bfriesen Exp $ */
+/* $Id: tiffiop.h,v 1.51.2.7 2011-03-21 21:09:19 fwarmerdam Exp $ */
 
 /*
  * Copyright (c) 1988-1997 Sam Leffler
@@ -59,10 +59,13 @@ extern void *lfind(const void *, const void *, size_t *, size_t,
 
 /*
   Libtiff itself does not require a 64-bit type, but bundled TIFF
-  utilities may use it.
+  utilities may use it.  
 */
+
+#if !defined(__xlC__) && !defined(__xlc__) // Already defined there (#2301)
 typedef TIFF_INT64_T  int64;
 typedef TIFF_UINT64_T uint64;
+#endif
 
 #include "tiffio.h"
 #include "tif_dir.h"
diff --git a/3rdparty/libtiff/tiffvers.h b/3rdparty/libtiff/tiffvers.h
index 314a22a0ae..a5607aafa9 100644
--- a/3rdparty/libtiff/tiffvers.h
+++ b/3rdparty/libtiff/tiffvers.h
@@ -1,4 +1,4 @@
-#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.9.4\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
+#define TIFFLIB_VERSION_STR "LIBTIFF, Version 3.9.5\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
 /*
  * This define can be used in code that requires
  * compilation-related definitions specific to a
@@ -6,4 +6,4 @@
  * version checking should be done based on the
  * string returned by TIFFGetVersion.
  */
-#define TIFFLIB_VERSION 20100615
+#define TIFFLIB_VERSION 20110409
diff --git a/3rdparty/readme.txt b/3rdparty/readme.txt
index b06f83d93e..5fdd2145bf 100644
--- a/3rdparty/readme.txt
+++ b/3rdparty/readme.txt
@@ -11,7 +11,6 @@ libjpeg 6b (6.2) - The Independent JPEG Group's JPEG software.
 
              HAVE_JPEG preprocessor flag must be set to make highgui use libjpeg.
              On UNIX systems configure script takes care of it.
-
 ------------------------------------------------------------------------------------
 libpng 1.4.3 - Portable Network Graphics library.
                Copyright (C) 1998-2010, Glenn Randers-Pehrson.
@@ -20,15 +19,13 @@ libpng 1.4.3 - Portable Network Graphics library.
 
                HAVE_PNG preprocessor flag must be set to make highgui use libpng.
                On UNIX systems configure script takes care of it.
-
 ------------------------------------------------------------------------------------
-libtiff 3.9.4 - Tag Image File Format (TIFF) Software
+libtiff 3.9.5 - Tag Image File Format (TIFF) Software
                 Copyright (c) 1988-1997 Sam Leffler
                 Copyright (c) 1991-1997 Silicon Graphics, Inc.
                 See libtiff home page http://www.libtiff.org
                 for details and links to the source code
 
-
                 HAVE_TIFF preprocessor flag must be set to make highgui use libtiff.
                 On UNIX systems configure script takes care of it.
 
@@ -42,9 +39,7 @@ zlib 1.2.5 - General purpose LZ77 compression library
 
              No preprocessor definition is needed to make highgui use this library -
              it is included automatically if either libpng or libtiff are used.
-
 ------------------------------------------------------------------------------------
-
 jasper-1.900.1 - JasPer is a collection of software
              (i.e., a library and application programs) for the coding
              and manipulation of images.  This software can handle image data in a
@@ -61,9 +56,7 @@ jasper-1.900.1 - JasPer is a collection of software
              (lib/libjasper*). To get the latest source code,
              please, visit the project homepage:
              http://www.ece.uvic.ca/~mdadams/jasper/
-
 ------------------------------------------------------------------------------------
-
 openexr-1.4.0 - OpenEXR is a high dynamic-range (HDR) image file format developed
                 by Industrial Light & Magic for use in computer imaging applications.
 
@@ -73,34 +66,15 @@ openexr-1.4.0 - OpenEXR is a high dynamic-range (HDR) image file format develope
 
              The project homepage: http://www.openexr.com/
 
-             OpenCV on Windows does not include openexr codec by default.
-             To add it, you will need to recompile highgui with OpenEXR support
-             using VS.NET2003 or VS.NET2005 (MSVC6 can not compile it):
-             1) download binaries (e.g. openexr-1.4.0-vs2005.zip)
-                from the official site.
-             2) copy
-                half.lib, iex.lib, ilmimf.lib ilmthread.lib imath.lib to
-                _graphics/lib
-             3) copy include/openexr/*.h to _graphics/include/openexr
-             4) open _make/opencv.sln
-             5) in highgui/_highgui.h uncomment
-                #define HAVE_ILMIMF 1
-             6) build debug/release configurations of highgui.
-
+             OpenCV does not include openexr codec.
+             To add it, you will need install OpenEXR, reconfigure OpenCV
+             using CMake (make sure OpenEXR library is found) and the rebuild OpenCV.
 ------------------------------------------------------------------------------------
-
-ffmpeg-0.6.0 - FFmpeg is a complete, cross-platform solution to record,
+ffmpeg-0.8.0 - FFmpeg is a complete, cross-platform solution to record,
              convert and stream audio and video. It includes libavcodec -
              the leading audio/video codec library, and also libavformat, libavutils and
              other helper libraries that are used by OpenCV (in highgui module) to
              read and write video files.
 
              The project homepage: http://ffmpeg.org/
-
-------------------------------------------------------------------------------------
-
-videoInput-0.1995 - Video capturing library for Windows using DirectShow as backend
-             Written by Theodore Watson
-             http://muonics.net/school/spring05/videoInput/
-
 ------------------------------------------------------------------------------------
diff --git a/3rdparty/zlib/CMakeLists.txt b/3rdparty/zlib/CMakeLists.txt
index 1fc3c5d14f..1964af039d 100644
--- a/3rdparty/zlib/CMakeLists.txt
+++ b/3rdparty/zlib/CMakeLists.txt
@@ -29,7 +29,7 @@ set_target_properties(${the_target}
     PROPERTIES
         OUTPUT_NAME "${the_target}"
         DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/lib"
+        ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}"
     )
 
 if(ENABLE_SOLUTION_FOLDERS)
@@ -38,5 +38,5 @@ endif()
 	
 if(NOT BUILD_SHARED_LIBS)
     install(TARGETS ${the_target}
-	    ARCHIVE DESTINATION share/opencv/3rdparty/lib COMPONENT main)
+	    ARCHIVE DESTINATION share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 endif()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c4fbbdb15e..9e1347b61c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,24 +11,39 @@
 
 set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
 
-# Add these standard paths to the search paths for FIND_LIBRARY
-# to find libraries from these locations first
-if(UNIX)
-    set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /lib /usr/lib)
-endif()
+# Following block can broke build in case of cross-compilng
+# but CMAKE_CROSSCOMPILING variable will be set only on project(OpenCV) command
+# so we will try to detect crosscompiling by presense of CMAKE_TOOLCHAIN_FILE
+if(NOT CMAKE_TOOLCHAIN_FILE)
+    # Add these standard paths to the search paths for FIND_LIBRARY
+    # to find libraries from these locations first
+    if(UNIX)
+        set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /lib /usr/lib)
+    endif()
 
+    # it _must_ go before PROJECT(OpenCV) in order to work
+    if(WIN32)
+        set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
+    else()
+        set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Installation Directory")
+    endif()
 
-# it _must_ go before PROJECT(OpenCV) in order to work
-if(WIN32)
-    set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "Installation Directory")
-else()
-    set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "Installation Directory")
-endif()
+    if(MSVC)
+        set(CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE)
+    endif()
+endif(NOT CMAKE_TOOLCHAIN_FILE)
 
-set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+# --------------------------------------------------------------
+# Top level OpenCV project
+# --------------------------------------------------------------
+cmake_minimum_required(VERSION 2.4)
+project(OpenCV)
 
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE)
+if(DEFINED CMAKE_BUILD_TYPE)
+    set_property( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES} )
+endif()
+
 set(CMAKE_C_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE)
 set(CMAKE_C_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE)
 set(CMAKE_CXX_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE)
@@ -40,30 +55,10 @@ set(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "" CACHE INTERNAL "" FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "" CACHE INTERNAL "" FORCE)
 set(CMAKE_VERBOSE OFF CACHE BOOL "Verbose mode")
-
-
-if (WIN32)
-    if(${CMAKE_GENERATOR} MATCHES "(MinGW)|(MSYS)")
-        set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG" CACHE STRING "")
-    endif()
-endif()
-
 if(CMAKE_VERBOSE)
     set(CMAKE_VERBOSE_MAKEFILE 1)
 endif()
 
-
-project(OpenCV)
-
-
-cmake_minimum_required(VERSION 2.4)
-
-
-if(MSVC)
-    set(CMAKE_USE_RELATIVE_PATHS ON CACHE INTERNAL "" FORCE)
-endif()
-
-
 # --------------------------------------------------------------
 # Indicate CMake 2.7 and above that we don't want to mix relative
 #  and absolute paths in linker lib lists.
@@ -86,18 +81,21 @@ set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries (.dll/.so) instead o
 set(BUILD_WITH_DEBUG_INFO ON CACHE BOOL "Include debug info into debug libs")
 
 # ----------------------------------------------------------------------------
-#  Current version number:
+#  Get actual OpenCV version number from sources
 # ----------------------------------------------------------------------------
-set(OPENCV_VERSION "2.3.0")
-
-string(REGEX MATCHALL "[0-9]" OPENCV_VERSION_PARTS "${OPENCV_VERSION}")
-
-list(GET OPENCV_VERSION_PARTS 0 OPENCV_VERSION_MAJOR)
-list(GET OPENCV_VERSION_PARTS 1 OPENCV_VERSION_MINOR)
-list(GET OPENCV_VERSION_PARTS 2 OPENCV_VERSION_PATCH)
+SET(OPENCV_VERSION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/modules/core/include/opencv2/core/version.hpp")
+FILE(STRINGS "${OPENCV_VERSION_FILE}" OPENCV_VERSION_PARTS REGEX "#define CV_.+OR_VERSION[ ]+[0-9]+" )
+string(REGEX REPLACE ".+CV_MAJOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MAJOR "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_MINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_MINOR "${OPENCV_VERSION_PARTS}")
+string(REGEX REPLACE ".+CV_SUBMINOR_VERSION[ ]+([0-9]+).*" "\\1" OPENCV_VERSION_PATCH "${OPENCV_VERSION_PARTS}")
+set(OPENCV_VERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
 
 set(OPENCV_SOVERSION "${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}")
 
+# create a dependency on version file
+# we will never use output of the following command but cmake will rerun if version file changes
+configure_file("${OPENCV_VERSION_FILE}" "${CMAKE_BINARY_DIR}/junk/version.junk" COPYONLY)
+
 if(WIN32)
     # Postfix of DLLs:
     set(OPENCV_DLLVERSION "${OPENCV_VERSION_MAJOR}${OPENCV_VERSION_MINOR}${OPENCV_VERSION_PATCH}")
@@ -108,12 +106,56 @@ else()
     set(OPENCV_DEBUG_POSTFIX)
 endif()
 
+#name mangling
+set(OPENCV_INCLUDE_PREFIX include)
+if(UNIX AND NOT ANDROID AND BUILD_SHARED_LIBS)
+    option(OPENCV_MANGLED_INSTALL_PATHS "Enables mangled install paths, that help with side by side installs." False)
+    if(OPENCV_MANGLED_INSTALL_PATHS)
+      set(OPENCV_INCLUDE_PREFIX include/opencv-${OPENCV_VERSION})
+    endif()
+endif()
+
+# SUBDIRECTORIES:
+# Save libs and executables in the same place
+set(LIBRARY_OUTPUT_PATH "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Output directory for libraries" )
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Output directory for applications" )
+
+if(ANDROID OR WIN32)
+    set(OPENCV_DOC_INSTALL_PATH doc)
+elseif(OPENCV_MANGLED_INSTALL_PATHS)
+    set(OPENCV_DOC_INSTALL_PATH share/OpenCV-${OPENCV_VERSION}/doc)
+else()
+    set(OPENCV_DOC_INSTALL_PATH share/OpenCV/doc)
+endif()
+
+if(ANDROID)
+    set(OPENCV_LIB_INSTALL_PATH libs/${ARMEABI_NDK_NAME})
+else()
+    set(OPENCV_LIB_INSTALL_PATH lib${LIB_SUFFIX})
+endif()
+
+set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${OPENCV_LIB_INSTALL_PATH}")
+set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+# search packages for host system instead of packages for target system
+# in case of cross compilation thess macro should be defined by toolchain file
+if(NOT COMMAND find_host_package)
+    macro(find_host_package)
+        find_package(${ARGN})
+    endmacro()
+endif()
+if(NOT COMMAND find_host_program)
+    macro(find_host_program)
+        find_program(${ARGN})
+    endmacro()
+endif()
+
 # ----------------------------------------------------------------------------
 # Use statically or dynamically linked CRT?
 # Default: dynamic
 # ----------------------------------------------------------------------------
 if(WIN32 AND NOT BUILD_SHARED_LIBS)
-  option (BUILD_WITH_STATIC_CRT "Enables use of staticaly linked CRT" OFF)
+  option (BUILD_WITH_STATIC_CRT "Enables use of staticaly linked CRT" ON)
 endif()
   
 if(MSVC)
@@ -125,18 +167,15 @@ if(MSVC)
                 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
            if(${flag_var} MATCHES "/MD")
               string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-           endif(${flag_var} MATCHES "/MD")
-
+           endif()
            if(${flag_var} MATCHES "/MDd")
               string(REGEX REPLACE "/MDd" "/MTd" ${flag_var} "${${flag_var}}")
-           endif(${flag_var} MATCHES "/MDd")           
+           endif()
         endforeach(flag_var)
         
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib")
-        
         set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmt.lib")
         set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /NODEFAULTLIB:libcmtd.lib")
-                
     else(BUILD_WITH_STATIC_CRT)
         foreach(flag_var
                 CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
@@ -145,30 +184,28 @@ if(MSVC)
                 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
            if(${flag_var} MATCHES "/MT")
               string(REGEX REPLACE "/MT" "/MD" ${flag_var} "${${flag_var}}")
-           endif(${flag_var} MATCHES "/MT")
-
+           endif()
            if(${flag_var} MATCHES "/MTd")
               string(REGEX REPLACE "/MTd" "/MDd" ${flag_var} "${${flag_var}}")
-           endif(${flag_var} MATCHES "/MTd")           
+           endif()
         endforeach(flag_var)
-
     endif(BUILD_WITH_STATIC_CRT)
 
     if(NOT BUILD_WITH_DEBUG_INFO)
         string(REPLACE "/debug" "" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/DEBUG" "" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/INCREMENTAL:YES" "/INCREMENTAL:NO" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
-        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
+        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
 
         string(REPLACE "/debug" "" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/DEBUG" "" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/INCREMENTAL:YES" "/INCREMENTAL:NO" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
-        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO" CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
+        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
 
         string(REPLACE "/debug" "" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/DEBUG" "" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
         string(REPLACE "/INCREMENTAL:YES" "/INCREMENTAL:NO" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
-        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+        string(REPLACE "/INCREMENTAL " "/INCREMENTAL:NO " CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
 
         string(REPLACE "/Zi" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
         string(REPLACE "/Zi" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
@@ -186,24 +223,23 @@ set(PACKAGE_STRING "${PACKAGE} ${OPENCV_VERSION}")
 set(PACKAGE_TARNAME "${PACKAGE}")
 set(PACKAGE_VERSION "${OPENCV_VERSION}")
 
-
 # ----------------------------------------------------------------------------
 #  Autodetect if we are in a SVN repository
 # ----------------------------------------------------------------------------
-find_program(SVNVERSION_PATH svnversion)
+find_host_program(SVNVERSION_PATH svnversion)
 mark_as_advanced(force SVNVERSION_PATH)
 if(SVNVERSION_PATH)
     message(STATUS "Extracting svn version, please wait...")
     execute_process(COMMAND ${SVNVERSION_PATH} -n ${OpenCV_SOURCE_DIR} OUTPUT_VARIABLE SVNVERSION_RESULT)
 
     if(SVNVERSION_RESULT MATCHES "exported")
-       # This is NOT a svn repository:
-       set(OPENCV_SVNVERSION "")
+        # This is NOT a svn repository:
+        set(OPENCV_SVNVERSION "")
+        message(STATUS "SVNVERSION: exported")
     else()
         set(OPENCV_SVNVERSION " svn:${SVNVERSION_RESULT}")
+        message(STATUS "SVNVERSION: ${OPENCV_SVNVERSION}")
     endif()
-
-    message(STATUS "SVNVERSION: ${OPENCV_SVNVERSION}")
 else()
     # We don't have svnversion:
     set(OPENCV_SVNVERSION "")
@@ -229,11 +265,11 @@ if(CMAKE_COMPILER_IS_GNUCXX)
                   OUTPUT_STRIP_TRAILING_WHITESPACE)           
         
     # Typical output in CMAKE_OPENCV_GCC_VERSION_FULL: "c+//0 (whatever) 4.2.3 (...)"
-    #  Look for the version number
-    string(REGEX MATCH "[0-9].[0-9].[0-9]" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
+    # Look for the version number
+    string(REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" CMAKE_GCC_REGEX_VERSION "${CMAKE_OPENCV_GCC_VERSION_FULL}")
 
     # Split the three parts:
-    string(REGEX MATCHALL "[0-9]" CMAKE_OPENCV_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}")
+    string(REGEX MATCHALL "[0-9]+" CMAKE_OPENCV_GCC_VERSIONS "${CMAKE_GCC_REGEX_VERSION}")
 
     list(GET CMAKE_OPENCV_GCC_VERSIONS 0 CMAKE_OPENCV_GCC_VERSION_MAJOR)
     list(GET CMAKE_OPENCV_GCC_VERSIONS 1 CMAKE_OPENCV_GCC_VERSION_MINOR)
@@ -250,10 +286,8 @@ if(CMAKE_COMPILER_IS_GNUCXX)
             set(MINGW64 1)
         endif()
     endif()
-
 endif()
 
-
 # ----------------------------------------------------------------------------
 # Detect Intel ICC compiler -- for -fPIC in 3rdparty ( UNIX ONLY ):
 #  see  include/opencv/cxtypes.h file for related   ICC & CV_ICC defines.
@@ -278,7 +312,6 @@ if(UNIX)
     endif()
 endif()
 
-
 # ----------------------------------------------------------------------------
 #       CHECK FOR SYSTEM LIBRARIES, OPTIONS, ETC..
 # ----------------------------------------------------------------------------
@@ -288,6 +321,9 @@ endif()
 set(BUILD_EXAMPLES OFF CACHE BOOL "Build all examples")
 set(INSTALL_C_EXAMPLES OFF CACHE BOOL "Install C examples")
 set(INSTALL_PYTHON_EXAMPLES OFF CACHE BOOL "Install Python examples")
+if(ANDROID)
+    set(INSTALL_ANDROID_EXAMPLES OFF CACHE BOOL "Install Android examples")
+endif()
 
 # Build tests:
 # ===================================================
@@ -303,6 +339,9 @@ endif()
 
 include(OpenCVPCHSupport.cmake REQUIRED)
 include(OpenCVModule.cmake REQUIRED)
+if(ANDROID)
+    include(OpenCVAndroidProject.cmake REQUIRED)
+endif()
 
 if(PCHSupport_FOUND)
     SET(USE_PRECOMPILED_HEADERS ON CACHE BOOL "Use precompiled headers")
@@ -316,32 +355,28 @@ if(UNIX)
     include(CheckIncludeFile)
 endif()
 
-#if(MSVC)
-#   set(DEFAULT_ENABLE_OPENMP ON)
-#else()
-#   set(DEFAULT_ENABLE_OPENMP OFF)
-#endif()
-#set(ENABLE_OPENMP ${DEFAULT_ENABLE_OPENMP} CACHE BOOL "")
-
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(ENABLE_PROFILING OFF CACHE BOOL "Enable profiling in the GCC compiler (Add flags: -g -pg)")
     set(USE_OMIT_FRAME_POINTER ON CACHE BOOL "Enable -fomit-frame-pointer for GCC")
 
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES amd64*|x86_64*)
+    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES amd64.*|x86_64.*)
         set(X86_64 1)
     endif()
-    
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES i686*|i386*|x86*)
+    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES i686.*|i386.*|x86.*)
         set(X86 1)
     endif()
-
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES powerpc*)
+    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES powerpc.*)
         set(ENABLE_POWERPC ON CACHE BOOL "Enable PowerPC for GCC")
     endif ()
 
     if(X86 OR X86_64)
         # enable everything, since the available set of instructions is checked at runtime
-        set(USE_FAST_MATH ON CACHE BOOL "Enable -ffast-math")
+        IF ("${CMAKE_GCC_REGEX_VERSION}" VERSION_GREATER 4.5)
+            SET(_USE_FAST_MATH OFF)
+        ELSE()
+            SET(_USE_FAST_MATH ON)
+        ENDIF()
+        set(USE_FAST_MATH ${_USE_FAST_MATH} CACHE BOOL "Enable -ffast-math (not recommended for GCC 4.6.x)")
         set(ENABLE_SSE ON CACHE BOOL "Enable SSE instructions")
         set(ENABLE_SSE2 ON CACHE BOOL "Enable SSE2 instructions")
         set(ENABLE_SSE3 OFF CACHE BOOL "Enable SSE3 instructions")
@@ -393,6 +428,7 @@ set(WITH_EIGEN ON CACHE BOOL "Include Eigen2/Eigen3 support")
 set(WITH_CUDA ON CACHE BOOL "Include NVidia Cuda Runtime support")
 
 set(WITH_OPENNI OFF CACHE BOOL "Include OpenNI support")
+set(WITH_XIMEA OFF CACHE BOOL "Include XIMEA cameras support")
 
 # ===================================================
 # Macros that checks if module have been installed.
@@ -552,10 +588,10 @@ if(UNIX)
             set(HAVE_CAMV4L2 FALSE)
         endif()
 
-        if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD" AND NOT ANDROID)
-            set(OPENCV_LINKER_LIBS m pthread)
-        elseif(ANDROID)
+        if(ANDROID)
             set(OPENCV_LINKER_LIBS dl m log)
+        elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
+            set(OPENCV_LINKER_LIBS m pthread)
         else()
             set(OPENCV_LINKER_LIBS dl m pthread rt)
         endif()
@@ -580,6 +616,10 @@ if(WITH_JASPER AND NOT JASPER_FOUND)
     set(JASPER_LIBRARIES libjasper)
 endif()
 
+if(NOT ZLIB_FOUND)
+    set(ZLIB_LIBRARY zlib)
+endif()
+
 #message(STATUS "Graphic libraries: ${PNG_LIBRARIES} ${JPEG_LIBRARIES} ${TIFF_LIBRARIES} ${JASPER_LIBRARIES}")
 
 if(WITH_OPENEXR)
@@ -599,39 +639,46 @@ if (WIN32)
         set(BUILD_NEW_PYTHON_SUPPORT OFF)
     endif()
 endif()
+
 if(ANDROID)
     set(BUILD_NEW_PYTHON_SUPPORT OFF)
 endif()
 
 # Always try to find python
 # ===================================================
-find_package(PythonInterp)
-find_package(PythonLibs)
+find_host_package(PythonInterp)
+find_host_package(PythonLibs)
 
 # cmake 2.4 (at least on Ubuntu 8.04 (hardy)) don't define PYTHONLIBS_FOUND
 if(NOT PYTHONLIBS_FOUND AND PYTHON_INCLUDE_PATH)
     set(PYTHONLIBS_FOUND ON)
-endif(NOT PYTHONLIBS_FOUND AND PYTHON_INCLUDE_PATH)
+endif()
 
 execute_process(COMMAND ${PYTHON_EXECUTABLE} --version
       ERROR_VARIABLE PYTHON_VERSION_FULL
       OUTPUT_STRIP_TRAILING_WHITESPACE)
 
-string(REGEX MATCH "[0-9].[0-9]" PYTHON_VERSION_MAJOR_MINOR "${PYTHON_VERSION_FULL}")
-if(UNIX)
-    set(PYTHON_PLUGIN_INSTALL_PATH lib/python${PYTHON_VERSION_MAJOR_MINOR}/site-packages/opencv)
-    if(APPLE)
+string(REGEX MATCH "[0-9]+.[0-9]+" PYTHON_VERSION_MAJOR_MINOR "${PYTHON_VERSION_FULL}")
+if(CMAKE_HOST_UNIX)
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import *; print get_python_lib()"
+                    RESULT_VARIABLE PYTHON_CVPY_PROCESS
+                    OUTPUT_VARIABLE PYTHON_STD_PACKAGES_PATH
+                    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if("${PYTHON_STD_PACKAGES_PATH}" MATCHES "site-packages")
         set(PYTHON_PACKAGES_PATH lib/python${PYTHON_VERSION_MAJOR_MINOR}/site-packages CACHE PATH "Where to install the python packages.")
     else() #debian based assumed, install to the dist-packages.
-       set(PYTHON_PACKAGES_PATH lib/python${PYTHON_VERSION_MAJOR_MINOR}/dist-packages CACHE PATH "Where to install the python packages.")
+        set(PYTHON_PACKAGES_PATH lib/python${PYTHON_VERSION_MAJOR_MINOR}/dist-packages CACHE PATH "Where to install the python packages.")
     endif()
 endif()
-if(WIN32)
+if(CMAKE_HOST_WIN32)
     get_filename_component(PYTHON_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE CACHE)
-    set(PYTHON_PLUGIN_INSTALL_PATH "${PYTHON_PATH}/Lib/site-packages/opencv")
     set(PYTHON_PACKAGES_PATH "${PYTHON_PATH}/Lib/site-packages")
 endif()
 
+IF ("${PYTHON_VERSION_MAJOR_MINOR}" VERSION_GREATER 2.4)
+    SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} -B)
+ENDIF()
+
 # Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
 execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print numpy.distutils.misc_util.get_numpy_include_dirs()[0]"
             RESULT_VARIABLE PYTHON_NUMPY_PROCESS
@@ -654,13 +701,137 @@ execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import sphinx; print sphinx.__v
 
 set(HAVE_SPHINX 0)
 if(SPHINX_PROCESS EQUAL 0)
-    find_program(SPHINX_BUILD sphinx-build)
+    find_host_program(SPHINX_BUILD sphinx-build)
     if(SPHINX_BUILD)
         set(HAVE_SPHINX 1)
         message(STATUS "    Found Sphinx ${SPHINX_VERSION}: ${SPHINX_BUILD}")
     endif()
 endif()
 
+# Java support
+# ===================================================
+if (PYTHON_EXECUTABLE AND ANDROID AND ANDROID_API_LEVEL GREATER 7)
+    option(BUILD_JAVA_SUPPORT "Build with Java support" TRUE)
+endif()
+
+if (BUILD_JAVA_SUPPORT)
+    file(TO_CMAKE_PATH "$ENV{ANT_DIR}" ANT_DIR_ENV_PATH)
+    file(TO_CMAKE_PATH "$ENV{ProgramFiles}" ProgramFiles_ENV_PATH)
+
+    if(ANDROID)
+        file(TO_CMAKE_PATH "$ENV{ANDROID_SDK}" ANDROID_SDK_ENV_PATH)
+        
+        #find android SDK
+        find_host_program(ANDROID_EXECUTABLE
+            NAMES android.bat android
+            PATHS "${ANDROID_SDK_ENV_PATH}/tools/"
+                  "${ProgramFiles_ENV_PATH}/Android/android-sdk/tools/"
+                  "/opt/android-sdk/tools/"
+                  "/opt/android-sdk-linux_x86/tools/"
+                  "/opt/android-sdk-mac_x86/tools/"
+                  "/opt/android-sdk-linux_86/tools/"
+                  "/opt/android-sdk-mac_86/tools/"
+            )
+        if(ANDROID_EXECUTABLE)
+            message(STATUS "    Found android tool: ${ANDROID_EXECUTABLE}")
+
+            get_filename_component(ANDROID_SDK_TOOLS_PATH "${ANDROID_EXECUTABLE}" PATH)
+
+            #read source.properties
+            if (EXISTS "${ANDROID_SDK_TOOLS_PATH}/source.properties")
+                file(STRINGS "${ANDROID_SDK_TOOLS_PATH}/source.properties" ANDROID_SDK_TOOLS_SOURCE_PROPERTIES_LINES REGEX "^[ ]*[^#].*$")
+                foreach(line ${ANDROID_SDK_TOOLS_SOURCE_PROPERTIES_LINES})
+                    string(REPLACE "\\:" ":" line ${line})
+                    string(REPLACE "=" ";" line ${line})
+                    list(GET line 0 line_name)
+                    list(GET line 1 line_value)
+                    string(REPLACE "." "_" line_name ${line_name})
+                    SET(ANDROID_TOOLS_${line_name} "${line_value}")
+                    MARK_AS_ADVANCED(ANDROID_TOOLS_${line_name})
+                endforeach()
+            endif()
+            if (NOT ANDROID_TOOLS_Pkg_Revision)
+                SET(ANDROID_TOOLS_Pkg_Revision "Unknown")
+                MARK_AS_ADVANCED(ANDROID_TOOLS_Pkg_Revision)
+            endif()
+            if (NOT ANDROID_TOOLS_Pkg_Desc)
+                SET(ANDROID_TOOLS_Pkg_Desc "Android SDK Tools, revision ${ANDROID_TOOLS_Pkg_Revision}.")
+                if (NOT ANDROID_TOOLS_Pkg_Revision GREATER 11)
+                    SET(ANDROID_TOOLS_Pkg_Desc "${ANDROID_TOOLS_Pkg_Desc} It is recommended to update your SDK tools to revision 12 or newer.")
+                endif()
+                MARK_AS_ADVANCED(ANDROID_TOOLS_Pkg_Desc)
+            endif()
+
+            #get installed targets
+            execute_process(COMMAND ${ANDROID_EXECUTABLE} list target
+                RESULT_VARIABLE ANDROID_PROCESS
+                OUTPUT_VARIABLE ANDROID_SDK_TARGETS_FULL
+                ERROR_VARIABLE ANDROID_PROCESS_ERRORS
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+            string(REGEX MATCHALL "(^|\n)id: [0-9]+ or \"([^\n]+[0-9+])\"(\n|$)" ANDROID_SDK_TARGETS_FULL "${ANDROID_SDK_TARGETS_FULL}")
+
+            SET(ANDROID_SDK_TARGETS)
+            if (ANDROID_PROCESS EQUAL 0)
+                foreach(line ${ANDROID_SDK_TARGETS_FULL})
+                    string(REGEX REPLACE "(^|\n)id: [0-9]+ or \"([^\n]+[0-9+])\"(\n|$)" "\\2" line "${line}")
+                    list(APPEND ANDROID_SDK_TARGETS "${line}")
+                endforeach()
+            endif()
+
+            # detect ANDROID_SDK_TARGET if no target is provided by user
+            if (NOT ANDROID_SDK_TARGET)
+                set(desired_android_target_level ${ANDROID_API_LEVEL})
+                if (desired_android_target_level LESS 8)
+                    set(desired_android_target_level 8)
+                endif()
+                if (ANDROID_PROCESS EQUAL 0)
+                    math(EXPR desired_android_target_level_1 "${desired_android_target_level}-1")
+
+                    foreach(target ${ANDROID_SDK_TARGETS})
+                        string(REGEX MATCH "[0-9]+$" target_level "${target}")
+                        if (target_level GREATER desired_android_target_level_1)
+                           set(ANDROID_SDK_TARGET "${target}")
+                           break()
+                        endif()
+                    endforeach()
+                else()
+                    set(ANDROID_SDK_TARGET android-${desired_android_target_level})
+                    message(WARNING "Could not retrieve list of installed Android targets. Will try to use \"${ANDROID_SDK_TARGET}\" target")
+                endif()
+            endif()
+
+            SET(ANDROID_SDK_TARGET ${ANDROID_SDK_TARGET} CACHE STRING "SDK target for Android tests and samples")
+            if (ANDROID_PROCESS EQUAL 0)
+                set_property( CACHE ANDROID_SDK_TARGET PROPERTY STRINGS ${ANDROID_SDK_TARGETS} )
+            endif()
+            string(REGEX MATCH "[0-9]+$" ANDROID_SDK_TARGET_LEVEL "${ANDROID_SDK_TARGET}")
+        endif()
+    endif()
+
+    #find apache ant
+    find_host_program(ANT_EXECUTABLE NAMES ant.bat ant
+        PATHS "${ANT_DIR_ENV_PATH}/bin"
+              "${ProgramFiles_ENV_PATH}/apache-ant/bin"
+        )
+    if(ANT_EXECUTABLE)
+        execute_process(COMMAND ${ANT_EXECUTABLE} -version
+            OUTPUT_VARIABLE ANT_VERSION_FULL
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+        string(REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" ANT_VERSION "${ANT_VERSION_FULL}")
+
+        message(STATUS "    Found apache ant ${ANT_VERSION}: ${ANT_EXECUTABLE}")
+    endif()
+
+    if (ANDROID_EXECUTABLE AND ANT_EXECUTABLE AND (ANT_VERSION VERSION_GREATER 1.7) AND (ANDROID_SDK_TARGET_LEVEL GREATER 7))
+        SET(CAN_BUILD_ANDROID_PROJECTS TRUE)
+    else()
+        SET(CAN_BUILD_ANDROID_PROJECTS FALSE)
+    endif()
+endif()
+
+if(CAN_BUILD_ANDROID_PROJECTS)
+    SET(BUILD_ANDROID_EXAMPLES TRUE CACHE BOOL "Build examples for Android platform")
+endif()
 
 #YV
 ############################### QT ################################
@@ -675,22 +846,19 @@ if (WITH_QT)
     find_package(Qt4)
     if (QT4_FOUND)
         set(HAVE_QT 1)
-                add_definitions(-DHAVE_QT)#We need to define te macro this way, using cvconfig.h.cmake does not work
-
+        add_definitions(-DHAVE_QT)#We need to define te macro this way, using cvconfig.h.cmake does not work
         find_package (OpenGL QUIET)
 
-
-    #if (NOT WIN32)
-    if (WITH_QT_OPENGL)
-        if (QT_QTOPENGL_FOUND AND OPENGL_FOUND)
-            set(HAVE_QT_OPENGL 1)
-            add_definitions(-DHAVE_QT_OPENGL)
-            #link_directories("${OPENGL_LIBRARIES}")
-            set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${OPENGL_LIBRARIES})
+        #if (NOT WIN32)
+        if (WITH_QT_OPENGL)
+            if (QT_QTOPENGL_FOUND AND OPENGL_FOUND)
+                set(HAVE_QT_OPENGL 1)
+                add_definitions(-DHAVE_QT_OPENGL)
+                #link_directories("${OPENGL_LIBRARIES}")
+                set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${OPENGL_LIBRARIES})
+            endif()
         endif()
-    endif()
-    #endif()
-
+        #endif()
     endif()
 endif()
 
@@ -699,7 +867,6 @@ endif()
 if (WITH_TBB)
     if (UNIX AND NOT APPLE AND NOT ANDROID)
         PKG_CHECK_MODULES(TBB tbb)
-        message(STATUS "TBB detected: ${TBBLIB_FOUND}")
 
         if (TBB_FOUND)
             set(HAVE_TBB 1)
@@ -859,10 +1026,21 @@ if(WITH_OPENNI)
     include(OpenCVFindOpenNI.cmake)
 endif()
 
+############################### XIMEA ################################
+set(HAVE_XIMEA FALSE)
+ 
+if(WITH_XIMEA)
+    include(OpenCVFindXimea.cmake)
+endif()
+
+if(XIMEA_FOUND)
+    set(HAVE_XIMEA TRUE)
+endif()
+
 ############################## Eigen ##############################
 
 if(WITH_EIGEN)
-        find_path(EIGEN_INCLUDE_PATH "Eigen/Core"
+    find_path(EIGEN_INCLUDE_PATH "Eigen/Core"
             PATHS "/usr/local/include/eigen2" "/opt/include/eigen2" "/usr/include/eigen2"
             "/usr/local/include/eigen3" "/opt/include/eigen3" "/usr/include/eigen3"
             DOC "The path to Eigen2/Eigen3 headers")
@@ -877,7 +1055,6 @@ endif()
 
 if(WIN32)
     set(WITH_VIDEOINPUT ON CACHE BOOL "Build HighGUI with DirectShow support")
-    
     set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES} comctl32 gdi32 ole32)
 
     if(WITH_VIDEOINPUT)
@@ -897,9 +1074,10 @@ if(WIN32)
     endif()
 endif()
 
-
 ############## Android source tree for native camera ###############
-if(ANDROID)
+if(ANDROID AND ANDROID_API_LEVEL GREATER 7)
+    option(WITH_ANDROID_CAMERA "Build with native Android camera support" TRUE)
+
     SET (ANDROID_SOURCE_TREE "ANDROID_SOURCE_TREE-NOTFOUND" CACHE PATH 
 "Path to Android source tree.
 Set this variable to path to your Android sources to compile
@@ -912,27 +1090,18 @@ libnative_camera_rx.x.x.so for your Android")
             SET(BUILD_ANDROID_CAMERA_WRAPPER ON)
         endif()
     endif()
+    MARK_AS_ADVANCED(ANDROID_SOURCE_TREE)
 endif()
 
-
-################### DOXYGEN ###############
-
-#find_package(Doxygen)
-#
-#if(DOXYGEN_FOUND)
-#    set(BUILD_DOXYGEN_DOCS ON CACHE BOOL "Generate HTML docs using Doxygen")
-#endif()
-
-
 # ----------------------------------------------------------------------------
 #                   UPDATE CONFIG FILES & SCRIPTS:
 #
 #  CONFIGURE_FILE(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
-# If @ONLY is specified, only variables of the form @VAR@ will be
+#  If @ONLY is specified, only variables of the form @VAR@ will be
 #  replaces and ${VAR} will be ignored.
 #
 #  A directory will be created for each platform so the "cvconfig.h" file is
-#   not overwritten if cmake generates code in the same path.
+#  not overwritten if cmake generates code in the same path.
 # ----------------------------------------------------------------------------
 add_definitions(-DHAVE_CVCONFIG_H)
 
@@ -941,7 +1110,6 @@ set(OPENCV_CONFIG_FILE_INCLUDE_DIR "${CMAKE_BINARY_DIR}/" CACHE PATH "Where to c
 message(STATUS "Parsing 'cvconfig.h.cmake'")
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cvconfig.h.cmake" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h")
 
-
 # ---------------------------------------------------------------------------
 # The C+//0 include & link directories:
 # ---------------------------------------------------------------------------
@@ -951,12 +1119,14 @@ include_directories("."
     "${CMAKE_CURRENT_SOURCE_DIR}/include/opencv"
     )
 
-
 # ----------------------------------------------------------------------------
 #           Set the maximum level of warnings:
 # ----------------------------------------------------------------------------
 # Should be set to true for development
 set(OPENCV_WARNINGS_ARE_ERRORS OFF CACHE BOOL "Treat warnings as errors")
+if (WIN32 AND ${CMAKE_GENERATOR} MATCHES "(MinGW)|(MSYS)")
+    set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG" CACHE STRING "")
+endif()
 
 set(EXTRA_C_FLAGS "")
 set(EXTRA_C_FLAGS_RELEASE "")
@@ -970,7 +1140,6 @@ if(MSVC)
     # 64-bit portability warnings, in MSVC8
     if(MSVC80)
         set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /Wp64")
-
     endif()
     #if(MSVC90)
     #    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /D _BIND_TO_CURRENT_CRT_VERSION=1 /D _BIND_TO_CURRENT_VCLIBS_VERSION=1")
@@ -980,10 +1149,6 @@ if(MSVC)
         set(EXTRA_EXE_LINKER_FLAGS_RELEASE "${EXTRA_EXE_LINKER_FLAGS_RELEASE} /debug")
     endif()
 
-    #if(ENABLE_OPENMP)
-    #    set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} /openmp")
-    #endif()
-
     # Remove unreferenced functions: function level linking
     set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} /Gy")
     if(BUILD_WITH_DEBUG_INFO)
@@ -992,41 +1157,25 @@ if(MSVC)
 endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX)
-
     # High level of warnings.
     set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wall")
 
-    if(BUILD_WITH_STATIC_CRT)
-        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -static-libstdc++")
-    endif()
-
     # The -Wno-long-long is required in 64bit systems when including sytem headers.
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES x86_64*)
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long")
-    endif()
-    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES amd64*)
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long")
+    if(X86_64)
+        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long")
     endif()
 
     # We need pthread's
-    if(UNIX)
-      if(NOT ANDROID)
+    if(UNIX AND NOT ANDROID)
         set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -pthread")
-      endif()
     endif()
 
     if(OPENCV_WARNINGS_ARE_ERRORS)
         set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror")
     endif()
 
-    if(X86)
-        if(NOT MINGW64)
-            if(NOT X86_64)
-                if(NOT APPLE)
-                    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -march=i686")
-                endif()
-            endif()
-        endif()
+    if(X86 AND NOT MINGW64 AND NOT X86_64 AND NOT APPLE)
+        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -march=i686")
     endif()
 
     # Other optimizations
@@ -1058,11 +1207,11 @@ if(CMAKE_COMPILER_IS_GNUCXX)
             set(HAVE_GCC42_OR_NEWER 1)
         endif()
         
-        if(HAVE_GCC43_OR_NEWER OR APPLE)
+        if(HAVE_GCC42_OR_NEWER OR APPLE)
             if(ENABLE_SSSE3)
                 set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mssse3")
             endif()
-            if(HAVE_GCC42_OR_NEWER)
+            if(HAVE_GCC43_OR_NEWER)
                 if(ENABLE_SSE41)
                     set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -msse4.1")
                 endif()
@@ -1074,32 +1223,21 @@ if(CMAKE_COMPILER_IS_GNUCXX)
     endif()
 
     if(X86 OR X86_64)
-        if(NOT APPLE)
-            if(${CMAKE_SIZEOF_VOID_P} EQUAL 4)
-                set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mfpmath=387")
-            endif()
+        if(NOT APPLE AND ${CMAKE_SIZEOF_VOID_P} EQUAL 4)
+            set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -mfpmath=387")
         endif()
     endif()
 
     # Profiling?
     if(ENABLE_PROFILING)
         set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -pg -g")
-    else()
+    elseif(NOT APPLE)
         # Remove unreferenced functions: function level linking
-        if(NOT APPLE)
-            set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -ffunction-sections")
-        endif()
+        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -ffunction-sections")
     endif()
 
-    # Parallel mode
-    #if(ENABLE_OPENMP)
-    #    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -D_GLIBCXX_PARALLEL -fopenmp")
-    #    set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} gomp)
-    #endif()
-
     set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE} -DNDEBUG")
     set(EXTRA_C_FLAGS_DEBUG "${EXTRA_C_FLAGS_DEBUG} -O0 -DDEBUG -D_DEBUG")
-
     if(BUILD_WITH_DEBUG_INFO)
        set(EXTRA_C_FLAGS_DEBUG "${EXTRA_C_FLAGS_DEBUG} -ggdb3")
     endif()
@@ -1127,23 +1265,22 @@ if(MSVC)
 endif()
 
 # Extra link libs if the user selects building static libs:
-if(NOT BUILD_SHARED_LIBS)
-    if(CMAKE_COMPILER_IS_GNUCXX)
-        set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
-        set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS} -fPIC")
-    endif()
+if(NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX AND NOT ANDROID)
+    # Android does not need these settings because they are already set by toolchain file
+    set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
+    set(OPENCV_EXTRA_C_FLAGS "-fPIC ${OPENCV_EXTRA_C_FLAGS}")
 endif()
 
-
 # Add user supplied extra options (optimization, etc...)
 # ==========================================================
-set(OPENCV_EXTRA_C_FLAGS "" CACHE STRING "Extra compiler options")
-set(OPENCV_EXTRA_C_FLAGS_RELEASE "" CACHE STRING "Extra compiler options for Release build")
-set(OPENCV_EXTRA_C_FLAGS_DEBUG "" CACHE STRING "Extra compiler options for Debug build")
-set(OPENCV_EXTRA_EXE_LINKER_FLAGS "" CACHE STRING "Extra linker flags" FORCE)
-set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "" CACHE STRING "Extra linker flags for Release build" FORCE)
-set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "" CACHE STRING "Extra linker flags for Debug build" FORCE)
+set(OPENCV_EXTRA_C_FLAGS "${OPENCV_EXTRA_C_FLAGS}" CACHE STRING "Extra compiler options")
+set(OPENCV_EXTRA_C_FLAGS_RELEASE "${OPENCV_EXTRA_C_FLAGS_RELEASE}" CACHE STRING "Extra compiler options for Release build")
+set(OPENCV_EXTRA_C_FLAGS_DEBUG "${OPENCV_EXTRA_C_FLAGS_DEBUG}" CACHE STRING "Extra compiler options for Debug build")
+set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS}" CACHE STRING "Extra linker flags" FORCE)
+set(OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE "${OPENCV_EXTRA_EXE_LINKER_FLAGS_RELEASE}" CACHE STRING "Extra linker flags for Release build" FORCE)
+set(OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG "${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING "Extra linker flags for Debug build" FORCE)
 
+#combine all "extra" options
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_C_FLAGS} ${OPENCV_EXTRA_C_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${EXTRA_C_FLAGS_RELEASE} ${OPENCV_EXTRA_C_FLAGS_RELEASE}")
@@ -1155,10 +1292,8 @@ set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${EXTRA_EX
 set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${EXTRA_EXE_LINKER_FLAGS_DEBUG} ${OPENCV_EXTRA_EXE_LINKER_FLAGS_DEBUG}")
 
 # In case of Makefiles if the user does not setup CMAKE_BUILD_TYPE, assume it's Release:
-if (${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-    if("${CMAKE_BUILD_TYPE}" STREQUAL "")
-        set(CMAKE_BUILD_TYPE Release)
-    endif()
+if (${CMAKE_GENERATOR} MATCHES ".*Makefiles" AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
+    set(CMAKE_BUILD_TYPE Release)
 endif()
 
 if (WIN32 AND MSVC)
@@ -1178,31 +1313,16 @@ if (WIN32 AND MSVC)
     string(REPLACE "/EHsc" "/EHsc-" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
     string(REPLACE "/EHsc" "/EHsc-" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 
-  string(REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-  string(REPLACE "/Zm1000" " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+    string(REPLACE "/Zm1000" " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    string(REPLACE "/Zm1000" " " CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 endif()
 
 if("${CMAKE_CONFIGURE_LDFLAGS}")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_CONFIGURE_LDFLAGS}")
 endif("${CMAKE_CONFIGURE_LDFLAGS}")
 
-
-# ----------------------------------------------------------------------------
-#                       PROCESS SUBDIRECTORIES:
-# ----------------------------------------------------------------------------
-# Save libs and executables in the same place
-set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib CACHE PATH "Output directory for libraries" )
-set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Output directory for applications" )
-
-if(WIN32)
-set(OPENCV_DOC_INSTALL_PATH doc)
-else()
-set(OPENCV_DOC_INSTALL_PATH share/opencv/doc)
-endif()
-
-
 # --------------------------------------------------------------------------------------------
-#   Installation for CMake Module:  OpenCVConfig.cmake
+#  Installation for CMake Module:  OpenCVConfig.cmake
 #  Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake              -> For use *without* "make install"
 #  Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use with "make install"
 #  Part 3/3: ${BIN_DIR}/win-install/OpenCVConfig.cmake  -> For use within binary installers/packages
@@ -1211,65 +1331,68 @@ endif()
 # -------------------------------------------------------------------------------------------
 #  Part 1/3: ${BIN_DIR}/OpenCVConfig.cmake              -> For use *without* "make install"
 # -------------------------------------------------------------------------------------------
-
-# Name of libraries is: libcv.so.1.1.0, etc...
-#  OPENCV_DLLVERSION must be set to "110", etc..
-# Already done above.
-
-# Set CMAKE_INCLUDE_DIRS_CONFIGCMAKE to the list of include directories:
 set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"${CMAKE_CURRENT_SOURCE_DIR}/include\" \"${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
-set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"${CMAKE_CURRENT_SOURCE_DIR}\"")
-
+set(CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "${CMAKE_CURRENT_SOURCE_DIR}")
 set(CMAKE_LIB_DIRS_CONFIGCMAKE "${LIBRARY_OUTPUT_PATH}")
+set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"${CMAKE_BINARY_DIR}/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
 
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig.cmake" IMMEDIATE @ONLY)
-
+#support for version checking when finding opencv. find_package(OpenCV 2.3.1 EXACT) should now work.
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/OpenCVConfig-version.cmake" IMMEDIATE @ONLY)
 # --------------------------------------------------------------------------------------------
 #  Part 2/3: ${BIN_DIR}/unix-install/OpenCVConfig.cmake -> For use *with* "make install"
 # -------------------------------------------------------------------------------------------
-# Set CMAKE_INCLUDE_DIRS_CONFIGCMAKE to the list of include directories:
+set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_PREFIX}/opencv" "\${OpenCV_INSTALL_PATH}/${OPENCV_INCLUDE_PREFIX}\"")
 
-set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\${THIS_OPENCV_CONFIG_PATH}/../../include/opencv" "\${THIS_OPENCV_CONFIG_PATH}/../../include\"")
-set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"\"")
+set(CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "")
+if(ANDROID)
+    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/libs/\${ARMEABI_NDK_NAME}\"")
+    set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/share/OpenCV/3rdparty/libs/\${ARMEABI_NDK_NAME}\"")
+else()
+    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/${OPENCV_LIB_INSTALL_PATH}\"")
+    set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
+    if(OPENCV_MANGLED_INSTALL_PATHS)
+      set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_INSTALL_PATH}/share/OpenCV-${OPENCV_VERSION}/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
+    endif()
+endif()
 
-set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${THIS_OPENCV_CONFIG_PATH}/../../lib\"")
-
-exec_program(mkdir ARGS "-p \"${CMAKE_BINARY_DIR}/unix-install/\"" OUTPUT_VARIABLE RET_VAL)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" IMMEDIATE @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig-version.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake" IMMEDIATE @ONLY)
 
 if(UNIX)
-    # For a command "FIND_PACKAGE(FOO)", CMake will look at the directory /usr/share|lib/cmake/FOO/FOOConfig.cmake, so:
-    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake DESTINATION share/opencv/)
-    install(CODE "exec_program(ln ARGS -sf \"${CMAKE_INSTALL_PREFIX}/share/opencv\" \"${CMAKE_INSTALL_PREFIX}/share/OpenCV\")")
+  #http://www.vtk.org/Wiki/CMake/Tutorials/Packaging reference
+  # For a command "find_package(<name> [major[.minor]] [EXACT] [REQUIRED|QUIET])"
+  # cmake will look in the following dir on unix:
+  #                <prefix>/(share|lib)/cmake/<name>*/                     (U)
+  #                <prefix>/(share|lib)/<name>*/                           (U)
+  #                <prefix>/(share|lib)/<name>*/(cmake|CMake)/             (U)
+  if(OPENCV_MANGLED_INSTALL_PATHS)
+    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake DESTINATION share/OpenCV-${OPENCV_VERSION}/)
+    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake DESTINATION share/OpenCV-${OPENCV_VERSION}/)
+  else()
+    install(FILES "${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig.cmake" DESTINATION share/OpenCV/)
+    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCVConfig-version.cmake DESTINATION share/OpenCV/)
+  endif()
+endif()
+
+if(ANDROID)
+    install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/android/android.toolchain.cmake" DESTINATION share/OpenCV)
 endif()
 
 # --------------------------------------------------------------------------------------------
 #  Part 3/3: ${BIN_DIR}/win-install/OpenCVConfig.cmake  -> For use within binary installers/packages
 # -------------------------------------------------------------------------------------------
 if(WIN32)
-    # Set CMAKE_INCLUDE_DIRS_CONFIGCMAKE to the list of include directories:
-    # support for 3rdparty libraries.
-    # This will expand to, for example, <program files>/OpenCV 1.1.0/include
-    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\${THIS_OPENCV_CONFIG_PATH}/include\" 
-                                        \"\${THIS_OPENCV_CONFIG_PATH}/include/opencv\" 
-                                        \"\${THIS_OPENCV_CONFIG_PATH}/3rdparty/include\"")
+    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\${OpenCV_CONFIG_PATH}/include\" \"\${OpenCV_CONFIG_PATH}/include/opencv\"")
+    set(CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE "")
+    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_CONFIG_PATH}/${OPENCV_LIB_INSTALL_PATH}\"")
+    set(CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE "\"\${OpenCV_CONFIG_PATH}/share/OpenCV/3rdparty/${OPENCV_LIB_INSTALL_PATH}\"")
 
-    set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"\${THIS_OPENCV_CONFIG_PATH}\"")
-
-    # This will expand to, for example, <program files>/OpenCV 1.1.0/lib
-    # support for 3rdparty libraries.
-    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\"\${THIS_OPENCV_CONFIG_PATH}/lib\" 
-                                    \"\${THIS_OPENCV_CONFIG_PATH}/3rdparty/lib\"")
-
-    #exec_program(${CMAKE_COMMAND} ARGS "-E make_directory \"${CMAKE_BINARY_DIR}/win-install/\"")
     exec_program(mkdir ARGS "-p \"${CMAKE_BINARY_DIR}/win-install/\"" OUTPUT_VARIABLE RET_VAL)
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCVConfig.cmake.in" "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" IMMEDIATE @ONLY)
+
     # Install the OpenCVConfig.cmake file which has the right paths pointing to the install directory 
     install(FILES "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake" DESTINATION "${CMAKE_INSTALL_PREFIX}/") 
-
-    # Add the OpenCV configuration header to the install path
-    # Useful for instance if a client application checks against the features OpenCV has been compiled with
-    install(FILES "${CMAKE_BINARY_DIR}/cvconfig.h" DESTINATION "${CMAKE_INSTALL_PREFIX}/include")
 endif()
 
 # --------------------------------------------------------------------------------------------
@@ -1283,27 +1406,27 @@ if(ANDROID)
     else()
         SET(OPENCV_LIBTYPE_CONFIGMAKE "STATIC")
     endif()
-    if(ARMEABI_V7A)
-        if(BUILD_ANDROID_CAMERA_WRAPPER)
-            set(CMAKE_CAMERA_LIBS_CONFIGCMAKE "native_camera_r${ANDROID_VERSION}")
-        else()
-            SET(CMAKE_CAMERA_LIBS_CONFIGCMAKE "")
-            file(GLOB CMAKE_CAMERA_LIBS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/lib/libnative_camera_r*.so")
-            foreach(cam_lib ${CMAKE_CAMERA_LIBS})
-                get_filename_component(cam_lib "${cam_lib}" NAME)
-                string(REGEX REPLACE "lib(native_camera_r[0-9]+\\.[0-9]+\\.[0-9]+)\\.so" "\\1" cam_lib "${cam_lib}")
-                SET(CMAKE_CAMERA_LIBS_CONFIGCMAKE "${CMAKE_CAMERA_LIBS_CONFIGCMAKE} ${cam_lib}")
-            endforeach()
-        endif()
+    if(BUILD_ANDROID_CAMERA_WRAPPER)
+        set(CMAKE_CAMERA_LIBS_CONFIGCMAKE "native_camera_r${ANDROID_VERSION}")
+    elseif(WITH_ANDROID_CAMERA)
+        SET(CMAKE_CAMERA_LIBS_CONFIGCMAKE "")
+        file(GLOB CMAKE_CAMERA_LIBS "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty/lib/${ARMEABI_NDK_NAME}/libnative_camera_r*.so")
+        foreach(cam_lib ${CMAKE_CAMERA_LIBS})
+            get_filename_component(cam_lib "${cam_lib}" NAME)
+            string(REGEX REPLACE "lib(native_camera_r[0-9]+\\.[0-9]+\\.[0-9]+)\\.so" "\\1" cam_lib "${cam_lib}")
+            SET(CMAKE_CAMERA_LIBS_CONFIGCMAKE "${CMAKE_CAMERA_LIBS_CONFIGCMAKE} ${cam_lib}")
+        endforeach()
     endif()
 endif(ANDROID)
+
 # -------------------------------------------------------------------------------------------
 #  Part 1/2: ${BIN_DIR}/OpenCV.mk              -> For use *without* "make install"
 # -------------------------------------------------------------------------------------------
 if(ANDROID)
-    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\$(RELATIVE_PREFIX)${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}/include\" \"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
-    set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "\"\$(RELATIVE_PREFIX)${CMAKE_CURRENT_SOURCE_DIR}\"")
-    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\$(RELATIVE_PREFIX)${LIBRARY_OUTPUT_PATH}")
+    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"${OPENCV_CONFIG_FILE_INCLUDE_DIR}\" \"${CMAKE_CURRENT_SOURCE_DIR}/include\" \"${CMAKE_CURRENT_SOURCE_DIR}/include/opencv\"")
+    set(CMAKE_BASE_INCLUDE_DIR_CONFIGCMAKE "\"${CMAKE_CURRENT_SOURCE_DIR}\"")
+    set(CMAKE_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)")
+
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/OpenCV.mk" IMMEDIATE @ONLY)
 endif(ANDROID)
 
@@ -1311,14 +1434,21 @@ endif(ANDROID)
 #  Part 2/2: ${BIN_DIR}/unix-install/OpenCV.mk -> For use with "make install"
 # -------------------------------------------------------------------------------------------
 if(ANDROID)
-    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../../include/opencv \$(OPENCV_THIS_DIR)/../../include")
-    set(CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE "")
-    set(CMAKE_LIB_DIRS_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../../lib")
+    set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE "\"\$(LOCAL_PATH)/\$(OPENCV_THIS_DIR)/../../include/opencv\" \"\$(LOCAL_PATH)/\$(OPENCV_THIS_DIR)/../../include\"")
+    set(CMAKE_BASE_INCLUDE_DIR_CONFIGCMAKE "")
+    set(CMAKE_LIBS_DIR_CONFIGCMAKE "\$(OPENCV_THIS_DIR)/../..")
+
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenCV.mk.in" "${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk" IMMEDIATE @ONLY)
-    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk DESTINATION share/opencv/)
+    install(FILES ${CMAKE_BINARY_DIR}/unix-install/OpenCV.mk DESTINATION share/OpenCV/)
 endif(ANDROID)
 
 # --------------------------------------------------------------------------------------------
+#according to man pkg-config
+#  The package name specified on the pkg-config command line is defined to
+#      be the name of the metadata file, minus the .pc extension. If a library
+#      can install multiple versions simultaneously, it must give each version
+#      its own name (for example, GTK 1.2 might have the package  name  "gtk+"
+#      while GTK 2.0 has "gtk+-2.0").
 #  Part 2/2: ${BIN_DIR}/unix-install/opencv.pc -> For use *with* "make install"
 # prefix=/usr
 # exec_prefix=${prefix}
@@ -1326,17 +1456,30 @@ endif(ANDROID)
 # includedir=${prefix}/include/opencv
 # -------------------------------------------------------------------------------------------
 set(prefix      ${CMAKE_INSTALL_PREFIX})
-set(exec_prefix     "\${prefix}")
-set(libdir      "\${exec_prefix}/lib")
-set(includedir      "\${prefix}/include")
-set(VERSION             ${OPENCV_VERSION})
+set(exec_prefix "\${prefix}")
+set(libdir      "\${exec_prefix}/lib${LIB_SUFFIX}")
+set(includedir  "\${prefix}/${OPENCV_INCLUDE_PREFIX}")
+set(VERSION     ${OPENCV_VERSION})
 
-configure_file("${CMAKE_CURRENT_SOURCE_DIR}/opencv.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/opencv.pc" @ONLY IMMEDIATE)
-
-if(UNIX)
-    install(FILES ${CMAKE_BINARY_DIR}/unix-install/opencv.pc DESTINATION lib/pkgconfig)
+set(OPENCV_PC_FILE_NAME opencv.pc)
+#need to be explicit with naming the pc file and version number for side by side installs to work.
+if(OPENCV_MANGLED_INSTALL_PATHS)
+  SET(OpenCV_LIB_COMPONENTS opencv_contrib opencv_legacy opencv_objdetect opencv_calib3d opencv_features2d opencv_video opencv_highgui opencv_ml opencv_imgproc opencv_flann opencv_core )
+  #be explicit about the library names.
+  set(OpenCV_LIB_COMPONENTS_ )
+  foreach( CVLib ${OpenCV_LIB_COMPONENTS})
+    set(OpenCV_LIB_COMPONENTS_ "${OpenCV_LIB_COMPONENTS_} ${libdir}/lib${CVLib}.so.${OPENCV_VERSION}" )
+  endforeach()
+  set(OpenCV_LIB_COMPONENTS ${OpenCV_LIB_COMPONENTS_})
+  set(OPENCV_PC_FILE_NAME "opencv-${OPENCV_VERSION}.pc")
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/opencv-XXX.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME}" @ONLY IMMEDIATE)
+else()
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/opencv.pc.cmake.in" "${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME}" @ONLY IMMEDIATE)
 endif()
 
+if(UNIX AND NOT ANDROID)
+  install(FILES ${CMAKE_BINARY_DIR}/unix-install/${OPENCV_PC_FILE_NAME} DESTINATION ${OPENCV_LIB_INSTALL_PATH}/pkgconfig)
+endif()
 
 # ----------------------------------------------------------------------------
 #   Uninstall target, for "make uninstall"
@@ -1346,62 +1489,24 @@ CONFIGURE_FILE(
   "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
   IMMEDIATE @ONLY)
 
-ADD_CUSTOM_TARGET(uninstall
-  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
-
-
-# ----------------------------------------------------------------------------
-#   CPack target
-# ----------------------------------------------------------------------------
+ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 
+#-----------------------------------
+# Source package:
+#-----------------------------------
 set(BUILD_PACKAGE ON CACHE BOOL "Enables 'make package_source' command")
 
 if(BUILD_PACKAGE)
-
-    configure_file(
-    Package.cmake.in
-    ${CMAKE_BINARY_DIR}/.cpack/Package.cmake
-    @ONLY
-    )
-
-    include(${CMAKE_BINARY_DIR}/.cpack/Package.cmake)
-
-    set(root_files README)
-
-    file(GLOB root_src_files *.in *.cmake CMakeLists.txt)
-
+    set(TARBALL_NAME "${CMAKE_PROJECT_NAME}-${OPENCV_VERSION_MAJOR}.${OPENCV_VERSION_MINOR}.${OPENCV_VERSION_PATCH}")
     if (NOT WIN32)
-        install(FILES ${root_files}
-                DESTINATION ${OPENCV_DOC_INSTALL_PATH}
-                COMPONENT main)
+        add_custom_target(package_source
+        #TODO: maybe we should not remove dll's
+        COMMAND tar --transform 's,^,${TARBALL_NAME}/,S' -cjpf ${CMAKE_CURRENT_BINARY_DIR}/${TARBALL_NAME}.tar.bz2 --exclude-vcs --exclude="*.pyc" --exclude="*.vcproj" --exclude="*/lib/*" --exclude="*.dll" ./
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
     else()
-        install(FILES ${root_files}
-                DESTINATION "."
-                COMPONENT main)
-        install(FILES ${root_src_files}
-                DESTINATION "."
-                COMPONENT src)
-        # Add the "win-install/OpenCVConfig.cmake" file to the "main" install component
-        install(FILES
-            "${CMAKE_BINARY_DIR}/win-install/OpenCVConfig.cmake"
-            DESTINATION "."
-            COMPONENT main
-            )
-        install(FILES
-            "include/CMakeLists.txt"
-            DESTINATION "include/"
-            COMPONENT src
-            )
-
-        install(DIRECTORY data samples DESTINATION "." COMPONENT main PATTERN ".svn" EXCLUDE)
-        install(DIRECTORY 3rdparty android modules doc DESTINATION "." COMPONENT src PATTERN ".svn" EXCLUDE)
-
-        # install TBB dlls
-        if(WIN32 AND HAVE_TBB)
-            string(REGEX REPLACE "/lib" "/bin" TBB_DLL_DIR "${TBB_LIB_DIR}")
-            install(PROGRAMS "${TBB_DLL_DIR}/tbb.dll" DESTINATION bin COMPONENT main)
-            install(PROGRAMS "${TBB_DLL_DIR}/tbb_debug.dll" DESTINATION bin COMPONENT main)
-        endif()
+        add_custom_target(package_source
+        COMMAND zip -9 -r ${CMAKE_CURRENT_BINARY_DIR}/${TARBALL_NAME}.zip . -x '*/.svn/*' '*.vcproj' '*.pyc'
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
     endif()
 endif()
 
@@ -1426,217 +1531,220 @@ add_subdirectory(include)
 add_subdirectory(modules)
 add_subdirectory(doc)
 add_subdirectory(data)
-
-if(BUILD_EXAMPLES OR INSTALL_PYTHON_EXAMPLES)
-    add_subdirectory(samples)
-endif()
-
 add_subdirectory(3rdparty)
 
+if(BUILD_EXAMPLES OR BUILD_ANDROID_EXAMPLES OR INSTALL_PYTHON_EXAMPLES)
+    add_subdirectory(samples)
+endif()
 
 # ----------------------------------------------------------------------------
 #   Summary:
 # ----------------------------------------------------------------------------
-message(STATUS "")
-message(STATUS "General configuration for opencv ${OPENCV_VERSION} =====================================")
-message(STATUS "")
-message(STATUS "    Built as dynamic libs?:     ${BUILD_SHARED_LIBS}")
-message(STATUS "    Compiler:                   ${CMAKE_COMPILER}")
-message(STATUS "    C++ flags (Release):        ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
-message(STATUS "    C++ flags (Debug):          ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
+macro(status text)
+    SET(status_cond)
+    SET(status_then)
+    SET(status_else)
+    
+    SET(status_current_name "cond")
+    foreach(arg ${ARGN})
+       if(arg STREQUAL "THEN")
+           SET(status_current_name "then")
+       elseif(arg STREQUAL "ELSE")
+           SET(status_current_name "else")
+       else()
+           LIST(APPEND status_${status_current_name} ${arg})
+       endif()
+    endforeach()
+
+    if(DEFINED status_cond)
+        SET(status_placeholder_length 32)
+        string(RANDOM LENGTH ${status_placeholder_length} ALPHABET " " status_placeholder)
+        string(LENGTH "${text}" status_text_length)
+        if (status_text_length LESS status_placeholder_length)
+            string(SUBSTRING "${text}${status_placeholder}" 0 ${status_placeholder_length} status_text)
+        elseif (DEFINED status_then OR DEFINED status_else)
+            message(STATUS "${text}")
+            SET(status_text "${status_placeholder}")
+        else()
+            SET(status_text "${text}")
+        endif()
+
+        if (DEFINED status_then OR DEFINED status_else)
+            if(${status_cond})
+                string(REPLACE ";" " " status_then "${status_then}")
+                message(STATUS "${status_text}" "${status_then}")
+            else()
+                string(REPLACE ";" " " status_else "${status_else}")
+                message(STATUS "${status_text}" "${status_else}")
+            endif()
+        else()
+            string(REPLACE ";" " " status_cond "${status_cond}")
+            message(STATUS "${status_text}" "${status_cond}")
+        endif()
+     else()
+         message(STATUS "${text}")
+     endif()
+endmacro()
+
+status("")
+status("General configuration for opencv ${OPENCV_VERSION} =====================================")
+status("")
+status("    Built as dynamic libs?:" BUILD_SHARED_LIBS THEN YES ELSE NO)
+status("    Compiler:"               CMAKE_COMPILER THEN "${CMAKE_COMPILER}" ELSE "${CMAKE_CXX_COMPILER}")
+status("    C++ flags (Release):"    ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE})
+status("    C++ flags (Debug):"      ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG})
 if(WIN32)
-message(STATUS "    Linker flags (Release):     ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
-message(STATUS "    Linker flags (Debug):       ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
+    status("    Linker flags (Release):" ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_RELEASE})
+    status("    Linker flags (Debug):"   ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS_DEBUG})
 else()
-message(STATUS "    Linker flags (Release):     ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
-message(STATUS "    Linker flags (Debug):       ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+    status("    Linker flags (Release):" ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_RELEASE})
+    status("    Linker flags (Debug):"   ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS_DEBUG})
+endif()
+
+if(ANDROID)
+    status("    Floating point type:" ${ARM_TARGET})
+    status("    Native API level:" android-${ANDROID_API_LEVEL})
+    status("    SDK target:" "${ANDROID_SDK_TARGET}")
 endif()
 
 #YV
-message(STATUS "")
-message(STATUS "  GUI: ")
+status("")
+status("  GUI: ")
 
 if (HAVE_QT)
-    message(STATUS "    QT 4.x:                     ${HAVE_QT}")
-    message(STATUS "    QT OpenGL support:          ${HAVE_QT_OPENGL}")
+    status("    QT 4.x:"            HAVE_QT        THEN YES ELSE NO)
+    status("    QT OpenGL support:" HAVE_QT_OPENGL THEN YES ELSE NO)
 else()
     if(WIN32)
-        message(STATUS "    Win32 UI:                   YES")
+        status("    Win32 UI:" YES)
     else()
         if(APPLE)
             if(WITH_CARBON)
-                message(STATUS "    Carbon:                     YES")
+                status("    Carbon:" YES)
             else()
-                message(STATUS "    Cocoa:                      YES")
+                status("    Cocoa:"  YES)
             endif()
         else()
-            message(STATUS "    GTK+ 2.x:                   ${HAVE_GTK}")
-            message(STATUS "    GThread:                    ${HAVE_GTHREAD}")
+            status("    GTK+ 2.x:" HAVE_GTK     THEN YES ELSE NO)
+            status("    GThread:"  HAVE_GTHREAD THEN YES ELSE NO)
         endif()
     endif()
 endif()
 
-message(STATUS "")
-message(STATUS "  Media I/O: ")
-if(ZLIB_FOUND)
-message(STATUS "    ZLib:                       ${ZLIB_FOUND}")
-else()
-message(STATUS "    ZLib:                       build")
-endif()
+# media
+status("")
+status("  Media I/O: ")
+status("    ZLib:"      ZLIB_FOUND                         THEN YES             ELSE build)
+status("    JPEG:"      NOT WITH_JPEG OR JPEG_FOUND        THEN ${JPEG_FOUND}   ELSE build)
+status("    PNG:"       NOT WITH_PNG OR PNG_FOUND          THEN ${PNG_FOUND}    ELSE build)
+status("    TIFF:"      NOT WITH_TIFF OR TIFF_FOUND        THEN ${TIFF_FOUND}   ELSE build)
+status("    JPEG 2000:" NOT WITH_JASPER OR JASPER_FOUND    THEN ${JASPER_FOUND} ELSE build)
+status("    OpenEXR:"   WITH_OPENEXR AND OPENEXR_FOUND     THEN YES             ELSE NO)
 
-if(NOT WITH_JPEG OR JPEG_FOUND)
-message(STATUS "    JPEG:                       ${JPEG_FOUND}")
-else()
-message(STATUS "    JPEG:                       build")
-endif()
-
-if(NOT WITH_PNG OR PNG_FOUND)
-message(STATUS "    PNG:                        ${PNG_FOUND}")
-else()
-message(STATUS "    PNG:                        build")
-endif()
-
-if(NOT WITH_TIFF OR TIFF_FOUND)
-message(STATUS "    TIFF:                       ${TIFF_FOUND}")
-else()
-message(STATUS "    TIFF:                       build")
-endif()
-
-if(NOT WITH_JASPER OR JASPER_FOUND)
-message(STATUS "    JPEG 2000:                  ${JASPER_FOUND}")
-else()
-message(STATUS "    JPEG 2000:                  build")
-endif()
-
-if(WITH_OPENEXR AND OPENEXR_FOUND)
-message(STATUS "    OpenEXR:                    YES")
-else()
-message(STATUS "    OpenEXR:                    NO")
-endif()
-
-if(NOT HAVE_OPENNI OR HAVE_OPENNI_PRIME_SENSOR_MODULE)
-message(STATUS "    OpenNI:                     ${HAVE_OPENNI}")
-else()
-message(STATUS "    OpenNI:                     ${HAVE_OPENNI} (WARNING: PrimeSensor Modules for OpenNI are not installed (not found in OPENNI_PRIME_SENSOR_MODULE_BIN_DIR).)")
-endif()
+status("    OpenNI:"    HAVE_OPENNI                        THEN YES             ELSE NO)
+status("    OpenNI PrimeSensor Modules:"
+                        HAVE_OPENNI_PRIME_SENSOR_MODULE    THEN YES             ELSE NO)
+status("    XIMEA:"     HAVE_XIMEA  THEN YES ELSE NO)
 
+# video
+status("")
 if(UNIX AND NOT APPLE)
-message(STATUS "")
-message(STATUS "  Video I/O: ")
-message(STATUS "    DC1394 1.x:                 ${HAVE_DC1394}")
-message(STATUS "    DC1394 2.x:                 ${HAVE_DC1394_2}")
-message(STATUS "    FFMPEG:                     ${HAVE_FFMPEG}")
-message(STATUS "      codec:                    ${HAVE_FFMPEG_CODEC}")
-message(STATUS "      format:                   ${HAVE_FFMPEG_FORMAT}")
-message(STATUS "      util:                     ${HAVE_FFMPEG_UTIL}")
-message(STATUS "      swscale:                  ${HAVE_FFMPEG_SWSCALE}")
-message(STATUS "      gentoo-style:             ${HAVE_GENTOO_FFMPEG}")
-message(STATUS "    GStreamer:                  ${HAVE_GSTREAMER}")
-message(STATUS "    UniCap:                     ${HAVE_UNICAP}")
-message(STATUS "    PvAPI:                      ${HAVE_PVAPI}")
-if(HAVE_LIBV4L)
-message(STATUS "    V4L/V4L2:                   Using libv4l")
-else()
-message(STATUS "    V4L/V4L2:                   ${HAVE_CAMV4L}/${HAVE_CAMV4L2}")
-endif()
-message(STATUS "    Xine:                       ${HAVE_XINE}")
-if(ANDROID)
-if (ARMEABI_V7A)
-if(BUILD_ANDROID_CAMERA_WRAPPER)
-message(STATUS "    AndroidNativeCamera:        build for Android ${ANDROID_VERSION}")
-else()
-message(STATUS "    AndroidNativeCamera:        use prebuilt libraries")
-endif(BUILD_ANDROID_CAMERA_WRAPPER)
-else(ARMEABI_V7A)
-message(STATUS "    AndroidNativeCamera:        NO")
-endif(ARMEABI_V7A)
-endif()
-endif() #if(UNIX AND NOT APPLE)
+    status("  Video I/O:")
+    status("    DC1394 1.x:"     HAVE_DC1394         THEN YES ELSE NO)
+    status("    DC1394 2.x:"     HAVE_DC1394_2       THEN YES ELSE NO)
+    status("    FFMPEG:"         HAVE_FFMPEG         THEN YES ELSE NO)
+    status("      codec:"        HAVE_FFMPEG_CODEC   THEN YES ELSE NO)
+    status("      format:"       HAVE_FFMPEG_FORMAT  THEN YES ELSE NO)
+    status("      util:"         HAVE_FFMPEG_UTIL    THEN YES ELSE NO)
+    status("      swscale:"      HAVE_FFMPEG_SWSCALE THEN YES ELSE NO)
+    status("      gentoo-style:" HAVE_GENTOO_FFMPEG  THEN YES ELSE NO)
+    status("    GStreamer:"      HAVE_GSTREAMER      THEN YES ELSE NO)
+    status("    UniCap:"         HAVE_UNICAP         THEN YES ELSE NO)
+    status("    PvAPI:"          HAVE_PVAPI          THEN YES ELSE NO)
+    status("    V4L/V4L2:"       HAVE_LIBV4L         THEN Using libv4l ELSE ${HAVE_CAMV4L}/${HAVE_CAMV4L2})
+    status("    Xine:"           HAVE_XINE           THEN YES ELSE NO)
 
-if(APPLE)
-message(STATUS "")
-if(WITH_QUICKTIME)
-message(STATUS "  Video I/O:                    QuickTime")
-else()
-message(STATUS "  Video I/O:                    QTKit")
-endif()
+    if(ANDROID)
+        if(WITH_ANDROID_CAMERA)
+            status("    AndroidNativeCamera:" BUILD_ANDROID_CAMERA_WRAPPER THEN "build for Android ${ANDROID_VERSION}" ELSE "use prebuilt libraries")
+        else()
+            status("    AndroidNativeCamera:" "NO (native camera requires Android API level 8 or higher)")
+        endif()
+    endif()
+elseif(APPLE)
+    status("  Video I/O:"        WITH_QUICKTIME      THEN QuickTime ELSE QTKit)
+elseif(WIN32)
+    status("  Video I/O:"        HAVE_VIDEOINPUT     THEN DirectShow ELSE NO)
 endif()
 
-if(WIN32 AND HAVE_VIDEOINPUT)
-message(STATUS "")
-message(STATUS "  Video I/O:                    DirectShow")
-endif()
-
-message(STATUS "")
-message(STATUS "  Interfaces: ")
-message(STATUS "    Python:                     ${BUILD_NEW_PYTHON_SUPPORT}")
-message(STATUS "    Python interpreter:         ${PYTHON_EXECUTABLE}")
-if (PYTHON_USE_NUMPY)
-message(STATUS "    Python numpy:               YES")
-else()
-message(STATUS "    Python numpy:               NO (Python interface will not cover OpenCV 2.x API)")
-endif()
+# Other third-party libraries
+status("")
+status("  Other third-party libraries:")
 
 if(WITH_IPP AND IPP_FOUND)
-message(STATUS "    Use IPP:                    ${IPP_LATEST_VERSION_STR} [${IPP_LATEST_VERSION_MAJOR}.${IPP_LATEST_VERSION_MINOR}.${IPP_LATEST_VERSION_BUILD}]")
-message(STATUS "         at:                    ${IPP_ROOT_DIR}")
-elseif(WITH_IPP AND NOT IPP_FOUND)
-message(STATUS "    Use IPP:                    IPP not found")
+    status("    Use IPP:" "${IPP_LATEST_VERSION_STR} [${IPP_LATEST_VERSION_MAJOR}.${IPP_LATEST_VERSION_MINOR}.${IPP_LATEST_VERSION_BUILD}]")
+    status("         at:" "${IPP_ROOT_DIR}")
 else()
-message(STATUS "    Use IPP:                    NO")
+    status("    Use IPP:"   WITH_IPP AND NOT IPP_FOUND THEN IPP not found ELSE NO)
 endif()
 
-if(HAVE_TBB)
-message(STATUS "    Use TBB:                    YES")
-else()
-message(STATUS "    Use TBB:                    NO")
-if(HAVE_THREADING_FRAMEWORK)
-message(STATUS "    Use ThreadingFramework:     YES")
-else()
-message(STATUS "    Use ThreadingFramework:     NO")
-endif()
+status("    Use TBB:" HAVE_TBB THEN YES ELSE NO)
+
+if(UNIX)
+    status("    Use ThreadingFramework:" HAVE_THREADING_FRAMEWORK THEN YES ELSE NO)
 endif()
 
-if (HAVE_CUDA)
-message(STATUS "    Use Cuda:                   YES")
+status("    Use Cuda:"  HAVE_CUDA  THEN YES ELSE NO)
+status("    Use Eigen:" HAVE_EIGEN THEN YES ELSE NO)
+
+# interfaces to other languages
+status("")
+status("  Interfaces:")
+status("    Python:"              BUILD_NEW_PYTHON_SUPPORT THEN YES ELSE NO)
+status("    Python interpreter:"  PYTHON_EXECUTABLE        THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_MAJOR_MINOR})" ELSE NO)
+status("    Python numpy:"        PYTHON_USE_NUMPY         THEN YES ELSE "NO (Python wrappers will not be generated)")
+if(ANDROID AND ANDROID_API_LEVEL LESS 8)
+    status("    Java:" "NO (Java API requires Android API level 8 or higher)")
 else()
-message(STATUS "    Use Cuda:                   NO")
+    status("    Java:" BUILD_JAVA_SUPPORT THEN YES ELSE NO)
 endif()
 
-if(HAVE_EIGEN)
-message(STATUS "    Use Eigen:                  YES")
-else()
-message(STATUS "    Use Eigen:                  NO")
+if(ANDROID)
+    status("    android tool:"    ANDROID_EXECUTABLE       THEN "${ANDROID_EXECUTABLE} (${ANDROID_TOOLS_Pkg_Desc})" ELSE NO)
+    status("    ant:"             ANT_EXECUTABLE           THEN "${ANT_EXECUTABLE} (ver ${ANT_VERSION})" ELSE NO)
 endif()
 
-message(STATUS "")
-message(STATUS "  Documentation: ")
-
-if(BUILD_DOCS AND PDFLATEX_COMPILER AND HAVE_SPHINX)
-message(STATUS "    Build Documentation:        YES")
+# documentation
+status("")
+status("  Documentation:")
+status("    Sphinx:"              HAVE_SPHINX              THEN "${SPHINX_BUILD} (ver ${SPHINX_VERSION})" ELSE NO)
+status("    PdfLaTeX compiler:"   PDFLATEX_COMPILER        THEN "${PDFLATEX_COMPILER}" ELSE NO)
+if (BUILD_DOCS AND HAVE_SPHINX)
+    status("    Build Documentation:" PDFLATEX_COMPILER THEN YES ELSE "YES (only HTML without math formulas)")
 else()
-message(STATUS "    Build Documentation:        NO")
+    status("    Build Documentation:" NO)
 endif()
 
-#if(BUILD_DOXYGEN_DOCS AND DOXYGEN_FOUND)
-#message(STATUS "    Doxygen HTMLs              YES")
-#else()
-#message(STATUS "    Doxygen HTMLs              NO")
-#endif()
+# samples and tests
+status("")
+status("  Tests and samples:")
+status("    Tests:"    BUILD_TESTS     THEN YES ELSE NO)
+status("    Examples:" BUILD_EXAMPLES  THEN YES ELSE NO)
 
-message(STATUS "")
-message(STATUS "    Install path:               ${CMAKE_INSTALL_PREFIX}")
-message(STATUS "")
-message(STATUS "    cvconfig.h is in:           ${OPENCV_CONFIG_FILE_INCLUDE_DIR}")
-message(STATUS "-----------------------------------------------------------------")
-message(STATUS "")
+if(ANDROID)
+   status("    Android tests:" BUILD_TESTS AND CAN_BUILD_ANDROID_PROJECTS THEN YES ELSE NO)
+   status("    Android examples:" BUILD_ANDROID_EXAMPLES THEN YES ELSE NO)
+endif()
+
+# auxiliary
+status("")
+status("  Install path:" "${CMAKE_INSTALL_PREFIX}")
+status("")
+status("  cvconfig.h is in:" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}")
+status("-----------------------------------------------------------------")
+status("")
 
 # warn in the case of in-source build
 if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
     message(WARNING "The source directory is the same as binary directory. \"make clean\" may damage the source tree")
 endif()
-
-#----------------------------------------------------------------------------
-#   Generate the OpenCVConfig.cmake file for unix
-#      installation in CMAKE_INSTALL_PREFIX
-#----------------------------------------------------------------------------
diff --git a/OpenCV.mk.in b/OpenCV.mk.in
index f3ce25c163..95fd93c62b 100644
--- a/OpenCV.mk.in
+++ b/OpenCV.mk.in
@@ -1,41 +1,53 @@
-RELATIVE_PREFIX:=.$(shell echo $(abspath $(LOCAL_PATH))| sed -e "s/\/[^\/]*/\/../g" )
-OPENCV_THIS_DIR:=$(RELATIVE_PREFIX)$(abspath $(dir $(lastword $(MAKEFILE_LIST))))
-OPENCV_LIBS_DIR:=@CMAKE_LIB_DIRS_CONFIGCMAKE@
-OPENCV_BASEDIR:=@CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@
+# In order to compile your application under cygwin
+# you need to define NDK_USE_CYGPATH=1 before calling ndk-build
+
+USER_LOCAL_PATH:=$(LOCAL_PATH)
+LOCAL_PATH:=$(subst ?,,$(firstword ?$(subst \, ,$(subst /, ,$(call my-dir)))))
+
+OPENCV_THIS_DIR:=$(patsubst $(LOCAL_PATH)\\%,%,$(patsubst $(LOCAL_PATH)/%,%,$(call my-dir)))
+OPENCV_LIBS_DIR:=@CMAKE_LIBS_DIR_CONFIGCMAKE@
+OPENCV_BASEDIR:=@CMAKE_BASE_INCLUDE_DIR_CONFIGCMAKE@
 OPENCV_LOCAL_C_INCLUDES:=@CMAKE_INCLUDE_DIRS_CONFIGCMAKE@
 
-OPENCV_MODULES := contrib calib3d objdetect features2d imgproc video  highgui ml legacy flann core
+OPENCV_MODULES := contrib calib3d objdetect features2d video imgproc highgui ml legacy flann core
+
+ifeq (${OPENCV_CAMERA_MODULES},off)
+	OPENCV_CAMERA_MODULES:=
+else
+	OPENCV_CAMERA_MODULES:=@CMAKE_CAMERA_LIBS_CONFIGCMAKE@
+endif
 
 OPENCV_LIB_TYPE:=@OPENCV_LIBTYPE_CONFIGMAKE@
+
 ifeq ($(OPENCV_LIB_TYPE),SHARED)
 	OPENCV_LIB_SUFFIX:=so
 	OPENCV_EXTRA_COMPONENTS:=
 else
 	OPENCV_LIB_SUFFIX:=a
-	OPENCV_MODULES+= androidcamera
-	OPENCV_EXTRA_COMPONENTS:=@JPEG_LIBRARIES@ @PNG_LIBRARIES@ @TIFF_LIBRARIES@ @JASPER_LIBRARIES@ zlib
+	ifeq (@WITH_ANDROID_CAMERA@,ON)
+		OPENCV_MODULES+= androidcamera
+	endif
+	OPENCV_EXTRA_COMPONENTS:=@JPEG_LIBRARIES@ @PNG_LIBRARIES@ @TIFF_LIBRARIES@ @JASPER_LIBRARIES@ @ZLIB_LIBRARY@
 endif
 
-OPENCV_CAMERA_MODULES := @CMAKE_CAMERA_LIBS_CONFIGCMAKE@
-
 define add_opencv_module
 	include $(CLEAR_VARS)
 	LOCAL_MODULE:=opencv_$1
-	LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/libopencv_$1.$(OPENCV_LIB_SUFFIX)
+	LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/libs/$(TARGET_ARCH_ABI)/libopencv_$1.$(OPENCV_LIB_SUFFIX)
 	include $(PREBUILT_@OPENCV_LIBTYPE_CONFIGMAKE@_LIBRARY)
 endef
 
 define add_opencv_extra_component
 	include $(CLEAR_VARS)
 	LOCAL_MODULE:=$1
-	LOCAL_SRC_FILES:=$(OPENCV_THIS_DIR)/3rdparty/lib/lib$1.a
+	LOCAL_SRC_FILES:=$(OPENCV_THIS_DIR)/3rdparty/libs/$(TARGET_ARCH_ABI)/lib$1.a
 	include $(PREBUILT_STATIC_LIBRARY)
 endef
 
 define add_opencv_camera_module
 	include $(CLEAR_VARS)
 	LOCAL_MODULE:=$1
-	LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/lib$1.so
+	LOCAL_SRC_FILES:=$(OPENCV_LIBS_DIR)/libs/$(TARGET_ARCH_ABI)/lib$1.so
 	include $(PREBUILT_SHARED_LIBRARY)
 endef
 
@@ -47,11 +59,16 @@ ifneq ($(OPENCV_BASEDIR),)
 	OPENCV_LOCAL_C_INCLUDES += $(foreach mod, $(OPENCV_MODULES), $(OPENCV_BASEDIR)/modules/$(mod)/include)
 endif
 
-OPENCV_LOCAL_LIBRARIES += $(foreach mod, $(OPENCV_MODULES), opencv_$(mod))
+ifeq ($(OPENCV_LIB_TYPE),STATIC)
+	OPENCV_LOCAL_LIBRARIES += $(foreach mod, $(OPENCV_MODULES), opencv_$(mod))
+endif
+
 OPENCV_LOCAL_LIBRARIES += $(OPENCV_EXTRA_COMPONENTS)
-OPENCV_LOCAL_CFLAGS := -fsigned-char -fPIC -DANDROID
+OPENCV_LOCAL_CFLAGS := -fPIC -DANDROID -fsigned-char
 
 include $(CLEAR_VARS)
 LOCAL_C_INCLUDES         += $(OPENCV_LOCAL_C_INCLUDES)
 LOCAL_STATIC_LIBRARIES   += $(OPENCV_LOCAL_LIBRARIES)
 LOCAL_CFLAGS             += $(OPENCV_LOCAL_CFLAGS)
+
+LOCAL_PATH:=$(USER_LOCAL_PATH)
diff --git a/OpenCVAndroidProject.cmake b/OpenCVAndroidProject.cmake
new file mode 100644
index 0000000000..d3f3b6c17a
--- /dev/null
+++ b/OpenCVAndroidProject.cmake
@@ -0,0 +1,143 @@
+# creates target "${_target}_android_project" for building standard Android project
+macro(add_android_project _target _path)
+    SET (android_dependencies opencv_contrib opencv_legacy opencv_objdetect opencv_calib3d opencv_features2d opencv_video opencv_highgui opencv_ml opencv_imgproc opencv_flann opencv_core)
+    if(NOT BUILD_SHARED_LIBS)
+        LIST(APPEND android_dependencies opencv_androidcamera)
+    endif()
+
+    if (ANDROID AND CAN_BUILD_ANDROID_PROJECTS)
+        file(GLOB_RECURSE res_files_all RELATIVE "${_path}" "${_path}/res/*")
+        file(GLOB_RECURSE jni_files_all RELATIVE "${_path}" "${_path}/jni/*.c*" "${_path}/jni/*.h*")
+        file(GLOB_RECURSE src_files_all RELATIVE "${_path}" "${_path}/src/*.java")
+        
+        #remove .svn 
+        set(res_files)
+        foreach(f ${res_files_all})
+            if(NOT f MATCHES "\\.svn")
+                list(APPEND res_files "${f}")
+            endif()
+        endforeach()
+        set(jni_files)
+        foreach(f ${jni_files_all})
+            if(NOT f MATCHES "\\.svn")
+                list(APPEND jni_files "${f}")
+            endif()
+        endforeach()
+        set(src_files)
+        foreach(f ${src_files_all})
+            if(NOT f MATCHES "\\.svn")
+                list(APPEND src_files "${f}")
+            endif()
+        endforeach()
+
+        # get temporary location for the project
+        file(RELATIVE_PATH build_path "${OpenCV_SOURCE_DIR}" "${_path}")
+        SET(build_path "${CMAKE_BINARY_DIR}/${build_path}")
+        
+        # copy project to temporary location
+        SET(${_target}_project_files)
+        foreach(f ${res_files} ${src_files} "AndroidManifest.xml")
+            if(NOT "${build_path}" STREQUAL "${_path}")
+                #this is not needed in case of in-source build
+                add_custom_command(
+                    OUTPUT "${build_path}/${f}"
+                    COMMAND ${CMAKE_COMMAND} -E copy "${_path}/${f}" "${build_path}/${f}"
+                    DEPENDS "${_path}/${f}"
+                    COMMENT ""
+                    )
+            endif()
+            list(APPEND ${_target}_project_files "${build_path}/${f}")
+        endforeach()
+
+        # process default.properties
+        file(STRINGS "${_path}/default.properties" default_properties REGEX "^android\\.library\\.reference\\.1=.+$")
+        if (default_properties)
+            # has opencv dependency
+            file(RELATIVE_PATH OPENCV_REFERENCE_PATH "${build_path}" "${CMAKE_BINARY_DIR}")
+            add_custom_command(
+                OUTPUT "${build_path}/default.properties"
+                OUTPUT "${build_path}/build.xml"
+                OUTPUT "${build_path}/local.properties"
+                OUTPUT "${build_path}/proguard.cfg"
+                COMMAND ${CMAKE_COMMAND} -E echo "" > "default.properties"
+                COMMAND ${ANDROID_EXECUTABLE} update project --name "${_target}" --target "${ANDROID_SDK_TARGET}" --library "${OPENCV_REFERENCE_PATH}" --path .
+                WORKING_DIRECTORY ${build_path}
+                DEPENDS ${${_target}_project_files}
+                DEPENDS "${CMAKE_BINARY_DIR}/default.properties"
+                DEPENDS "${CMAKE_BINARY_DIR}/AndroidManifest.xml"
+                COMMENT "Updating android project - ${_target}"
+                )
+        else()
+            # has no opencv dependency
+            add_custom_command(
+                OUTPUT "${build_path}/default.properties"
+                OUTPUT "${build_path}/build.xml"
+                OUTPUT "${build_path}/local.properties"
+                OUTPUT "${build_path}/proguard.cfg"
+                COMMAND ${CMAKE_COMMAND} -E echo "" > "default.properties"
+                COMMAND ${ANDROID_EXECUTABLE} update project --name "${_target}" --target "${ANDROID_SDK_TARGET}" --path .
+                WORKING_DIRECTORY ${build_path}
+                DEPENDS ${${_target}_project_files}
+                COMMENT "Updating android project - ${_target}"
+                )
+        endif()
+        
+        if("${build_path}" STREQUAL "${_path}")
+            #in case of in-source build default.properties file is not generated (it is just overwritten :)
+            SET_SOURCE_FILES_PROPERTIES("${build_path}/default.properties" PROPERTIES GENERATED FALSE)
+        endif()
+        
+        list(APPEND ${_target}_project_files "${build_path}/default.properties" "${build_path}/build.xml" "${build_path}/local.properties" "${build_path}/proguard.cfg")
+
+        # build native part of android project
+        if(jni_files)
+            INCLUDE_DIRECTORIES("${_path}/jni")
+
+            FILE(STRINGS "${_path}/jni/Android.mk" JNI_LIB_NAME REGEX "LOCAL_MODULE[ ]*:=[ ]*.*" )
+            string(REGEX REPLACE "LOCAL_MODULE[ ]*:=[ ]*([a-zA-Z_][a-zA-Z_0-9]*)[ ]*" "\\1" JNI_LIB_NAME "${JNI_LIB_NAME}")
+
+            SET(jni_sources)
+            foreach(src ${jni_files})
+                list(APPEND jni_sources "${_path}/${src}")
+            endforeach()
+
+            ADD_LIBRARY(${JNI_LIB_NAME} MODULE ${jni_sources})
+            TARGET_LINK_LIBRARIES(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_dependencies})
+
+            set_target_properties(${JNI_LIB_NAME} PROPERTIES
+                OUTPUT_NAME "${JNI_LIB_NAME}"
+                LIBRARY_OUTPUT_DIRECTORY "${build_path}/libs/${ARMEABI_NDK_NAME}"
+            )
+
+            ADD_CUSTOM_COMMAND(
+                TARGET ${JNI_LIB_NAME}
+                POST_BUILD
+                COMMAND ${CMAKE_STRIP} "${build_path}/libs/${ARMEABI_NDK_NAME}/*.so"
+                )
+        else()
+            SET(JNI_LIB_NAME)
+        endif()
+
+        add_custom_command(
+            OUTPUT "${build_path}/bin/${_target}-debug.apk"
+            OUTPUT "${CMAKE_BINARY_DIR}/bin/${_target}.apk"
+            COMMAND ${ANT_EXECUTABLE} -q -noinput -k debug
+            COMMAND ${CMAKE_COMMAND} -E copy "${build_path}/bin/${_target}-debug.apk" "${CMAKE_BINARY_DIR}/bin/${_target}.apk"
+            WORKING_DIRECTORY ${build_path}
+            DEPENDS ${${_target}_project_files}
+            DEPENDS "${LIBRARY_OUTPUT_PATH}/libopencv_java.so"
+            COMMENT "Generating bin/${_target}.apk"
+        )
+
+        ADD_CUSTOM_TARGET(${_target}_android_project ALL
+            DEPENDS "${build_path}/bin/${_target}-debug.apk"
+            DEPENDS "${CMAKE_BINARY_DIR}/bin/${_target}.apk"
+            )
+
+        add_dependencies(${_target}_android_project opencv_java ${JNI_LIB_NAME})
+
+        if("${ARGN}" STREQUAL "INSTALL" AND INSTALL_ANDROID_EXAMPLES)
+            install(FILES "${CMAKE_BINARY_DIR}/bin/${_target}.apk" DESTINATION "bin" COMPONENT main)
+        endif()
+    endif()
+endmacro()
diff --git a/OpenCVConfig-version.cmake.in b/OpenCVConfig-version.cmake.in
new file mode 100644
index 0000000000..ab11e3927c
--- /dev/null
+++ b/OpenCVConfig-version.cmake.in
@@ -0,0 +1,14 @@
+set(OpenCV_VERSION @OPENCV_VERSION@)
+set(PACKAGE_VERSION ${OpenCV_VERSION})
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if(PACKAGE_FIND_VERSION VERSION_LESS PACKAGE_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
diff --git a/OpenCVConfig.cmake.in b/OpenCVConfig.cmake.in
index 7234be2f2b..ff6016adbb 100644
--- a/OpenCVConfig.cmake.in
+++ b/OpenCVConfig.cmake.in
@@ -15,10 +15,19 @@
 #                                      with this path is NOT needed.
 #      - OpenCV_INCLUDE_DIRS         : The OpenCV include directories.
 #      - OpenCV_COMPUTE_CAPABILITIES : The version of compute capability
-#      - OpenCV_VERSION              : The version of this OpenCV build. Example: "1.2.0"
-#      - OpenCV_VERSION_MAJOR        : Major version part of OpenCV_VERSION. Example: "1"
-#      - OpenCV_VERSION_MINOR        : Minor version part of OpenCV_VERSION. Example: "2"
-#      - OpenCV_VERSION_PATCH        : Patch version part of OpenCV_VERSION. Example: "0"
+#      - OpenCV_VERSION              : The version of this OpenCV build. Example: "@OPENCV_VERSION@"
+#      - OpenCV_VERSION_MAJOR        : Major version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_MAJOR@"
+#      - OpenCV_VERSION_MINOR        : Minor version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_MINOR@"
+#      - OpenCV_VERSION_PATCH        : Patch version part of OpenCV_VERSION. Example: "@OPENCV_VERSION_PATCH@"
+#
+#    Advanced variables:
+#      - OpenCV_SHARED
+#      - OpenCV_CONFIG_PATH
+#      - OpenCV_INSTALL_PATH
+#      - OpenCV_LIB_COMPONENTS
+#      - OpenCV_EXTRA_COMPONENTS
+#      - OpenCV_USE_MANGLED_PATHS
+#      - OpenCV_HAVE_ANDROID_CAMERA
 #
 # =================================================================================================
 
@@ -28,9 +37,20 @@
 # ======================================================
 SET(OpenCV_COMPUTE_CAPABILITIES @OpenCV_CUDA_CC@)
 
+# Some additional settings are required if OpenCV is built as static libs
+set(OpenCV_SHARED @BUILD_SHARED_LIBS@)
+
+# Enables mangled install paths, that help with side by side installs
+set(OpenCV_USE_MANGLED_PATHS @OPENCV_MANGLED_INSTALL_PATHS@)
+
 # Extract the directory where *this* file has been installed (determined at cmake run-time)
-#  This variable may or may not be used below, depending on the parsing of OpenCVConfig.cmake
-get_filename_component(THIS_OPENCV_CONFIG_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(OpenCV_CONFIG_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH)
+
+# Get the absolute path with no ../.. relative marks, to eliminate implicit linker warnings
+get_filename_component(OpenCV_INSTALL_PATH "${OpenCV_CONFIG_PATH}/../.." REALPATH)
+
+# Presence of Android native camera support
+set (OpenCV_HAVE_ANDROID_CAMERA @WITH_ANDROID_CAMERA@)
 
 # ======================================================
 # Include directories to add to the user project:
@@ -38,7 +58,6 @@ get_filename_component(THIS_OPENCV_CONFIG_PATH "${CMAKE_CURRENT_LIST_FILE}" PATH
 
 # Provide the include directories to the caller
 SET(OpenCV_INCLUDE_DIRS @CMAKE_INCLUDE_DIRS_CONFIGCMAKE@)
-
 INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})
 
 # ======================================================
@@ -47,93 +66,100 @@ INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})
 
 # Provide the libs directory anyway, it may be needed in some cases.
 SET(OpenCV_LIB_DIR @CMAKE_LIB_DIRS_CONFIGCMAKE@)
-
 LINK_DIRECTORIES(${OpenCV_LIB_DIR})
 
 # ====================================================================
-# Link libraries: e.g.   opencv_core220.so, opencv_imgproc220d.lib, etc...
+# Link libraries: e.g.   libopencv_core.so, opencv_imgproc220d.lib, etc...
 # ====================================================================
+SET(OpenCV_LIB_COMPONENTS opencv_contrib opencv_legacy opencv_objdetect opencv_calib3d opencv_features2d opencv_video opencv_highgui opencv_ml opencv_imgproc opencv_flann opencv_core )
+#libraries order is very important because linker from Android NDK is one-pass linker
 if(NOT ANDROID)
-    set(OPENCV_LIB_COMPONENTS opencv_core opencv_imgproc opencv_features2d opencv_gpu opencv_calib3d opencv_objdetect opencv_video opencv_highgui opencv_ml opencv_legacy opencv_contrib opencv_flann)
-else()
-    #libraries order is very important because linker from Android NDK is one-pass linker
-    set(OPENCV_LIB_COMPONENTS opencv_contrib opencv_calib3d opencv_objdetect opencv_features2d opencv_imgproc opencv_video  opencv_highgui opencv_ml opencv_legacy  opencv_flann opencv_core )
-    IF (NOT @BUILD_SHARED_LIBS@)
-        set(OPENCV_LIB_COMPONENTS ${OPENCV_LIB_COMPONENTS} opencv_androidcamera)
-    ENDIF()
+    LIST(INSERT OpenCV_LIB_COMPONENTS 0 opencv_gpu)
+ELSEIF(NOT OpenCV_SHARED AND OpenCV_HAVE_ANDROID_CAMERA)
+    LIST(APPEND OpenCV_LIB_COMPONENTS opencv_androidcamera)
+endif()
+
+if(OpenCV_USE_MANGLED_PATHS)
+      #be explicit about the library names.
+      set(OpenCV_LIB_COMPONENTS_ )
+      foreach( CVLib ${OpenCV_LIB_COMPONENTS})
+        list(APPEND OpenCV_LIB_COMPONENTS_ ${OpenCV_LIB_DIR}/lib${CVLib}.so.@OPENCV_VERSION@ )
+      endforeach()
+      set(OpenCV_LIB_COMPONENTS ${OpenCV_LIB_COMPONENTS_})
 endif()
 
 SET(OpenCV_LIBS "")
-foreach(__CVLIB ${OPENCV_LIB_COMPONENTS})
-    # CMake>=2.6 supports the notation "debug XXd optimized XX"
-    if (CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-        # Modern CMake:
-        SET(OpenCV_LIBS ${OpenCV_LIBS} debug ${__CVLIB}@OPENCV_DLLVERSION@@OPENCV_DEBUG_POSTFIX@ optimized ${__CVLIB}@OPENCV_DLLVERSION@)
-    else(CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-        # Old CMake:
-        SET(OpenCV_LIBS ${OpenCV_LIBS} ${__CVLIB}@OPENCV_DLLVERSION@)
-    endif(CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-endforeach(__CVLIB)
+if(WIN32)
+  foreach(__CVLIB ${OpenCV_LIB_COMPONENTS})
+      # CMake>=2.6 supports the notation "debug XXd optimized XX"
+      if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_GREATER 2.4)
+          # Modern CMake:
+          SET(OpenCV_LIBS ${OpenCV_LIBS} debug ${__CVLIB}@OPENCV_DLLVERSION@@OPENCV_DEBUG_POSTFIX@ optimized ${__CVLIB}@OPENCV_DLLVERSION@)
+      else()
+          # Old CMake:
+          SET(OpenCV_LIBS ${OpenCV_LIBS} ${__CVLIB}@OPENCV_DLLVERSION@)
+      endif()
+  endforeach()
+else()
+  foreach(__CVLIB ${OpenCV_LIB_COMPONENTS})
+    SET(OpenCV_LIBS ${OpenCV_LIBS} ${__CVLIB})
+  endforeach()
+endif()
 
 # ==============================================================
 #  Extra include directories, needed by OpenCV 2 new structure
 # ==============================================================
-if(NOT @CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@ STREQUAL  "")
-    SET(BASEDIR @CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@)
-    foreach(__CVLIB ${OPENCV_LIB_COMPONENTS})
+if(NOT "@CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE@" STREQUAL  "")
+    foreach(__CVLIB ${OpenCV_LIB_COMPONENTS})
         # We only need the "core",... part here: "opencv_core" -> "core"
-        STRING(REGEX REPLACE "opencv_(.*)" "\\1" MODNAME ${__CVLIB})
-        INCLUDE_DIRECTORIES("${BASEDIR}/modules/${MODNAME}/include")
-    endforeach(__CVLIB)
-endif(NOT @CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@ STREQUAL  "")
+        STRING(REGEX REPLACE "opencv_(.*)" "\\1" __MODNAME ${__CVLIB})
+        INCLUDE_DIRECTORIES("@CMAKE_OPENCV2_INCLUDE_DIRS_CONFIGCMAKE@/modules/${__MODNAME}/include")
+    endforeach()
+endif()
 
 # For OpenCV built as static libs, we need the user to link against
 #  many more dependencies:
-set(OpenCV_SHARED @BUILD_SHARED_LIBS@)
-
 IF (NOT OpenCV_SHARED)
     # Under static libs, the user of OpenCV needs access to the 3rdparty libs as well:
-    if(WIN32 AND NOT ANDROID)
-        LINK_DIRECTORIES(@CMAKE_BASE_INCLUDE_DIRS_CONFIGCMAKE@/3rdparty/lib)
-    else()
-        LINK_DIRECTORIES("${THIS_OPENCV_CONFIG_PATH}/3rdparty/lib")
-    endif()    
+    LINK_DIRECTORIES(@CMAKE_3RDPARTY_LIB_DIRS_CONFIGCMAKE@)
 
     set(OpenCV_LIBS @OPENCV_LINKER_LIBS@ @IPP_LIBS@ @HIGHGUI_LIBRARIES@ ${OpenCV_LIBS})
+    set(OpenCV_EXTRA_COMPONENTS @JPEG_LIBRARIES@ @PNG_LIBRARIES@ @TIFF_LIBRARIES@ @JASPER_LIBRARIES@ @ZLIB_LIBRARY@)
 
-    set(OPENCV_EXTRA_COMPONENTS @JPEG_LIBRARIES@ @PNG_LIBRARIES@ @TIFF_LIBRARIES@ @JASPER_LIBRARIES@ zlib)
-
-    if (CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-        foreach(__EXTRA_LIB ${OPENCV_EXTRA_COMPONENTS})
+    if (WIN32 AND ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} VERSION_GREATER 2.4)
+        # Modern CMake:
+        foreach(__EXTRA_LIB ${OpenCV_EXTRA_COMPONENTS})
             set(OpenCV_LIBS ${OpenCV_LIBS}
                 debug ${__EXTRA_LIB}@OPENCV_DEBUG_POSTFIX@
                 optimized ${__EXTRA_LIB})
-        endforeach(__EXTRA_LIB)
-    else(CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-        set(OpenCV_LIBS ${OpenCV_LIBS} ${OPENCV_EXTRA_COMPONENTS})
-    endif(CMAKE_MAJOR_VERSION GREATER 2  OR  CMAKE_MINOR_VERSION GREATER 4)
-
+        endforeach()
+    else()
+        # Old CMake:
+        set(OpenCV_LIBS ${OpenCV_LIBS} ${OpenCV_EXTRA_COMPONENTS})
+    endif()
+    
+    if (APPLE)
+        set(OpenCV_LIBS ${OpenCV_LIBS} "-lbz2" "-framework Cocoa" "-framework QuartzCore" "-framework QTKit")
+    endif()
 ENDIF()
 
 # ======================================================
 #  Android camera helper macro
 # ======================================================
-IF (ANDROID)
+IF (OpenCV_HAVE_ANDROID_CAMERA)
   macro( COPY_NATIVE_CAMERA_LIBS target )
-    IF( ARMEABI_V7A)
-      get_target_property(target_location ${target} LOCATION)
-      get_filename_component(target_location "${target_location}" PATH)
-      file(GLOB camera_wrappers "${OpenCV_LIB_DIR}/libnative_camera_r*.so")
-      foreach(wrapper ${camera_wrappers})
-          ADD_CUSTOM_COMMAND(
-            TARGET ${target}
-            POST_BUILD
-            COMMAND ${CMAKE_COMMAND} -E copy "${wrapper}" "${target_location}"
-            )
-      endforeach()
-    ENDIF( ARMEABI_V7A )
+    get_target_property(target_location ${target} LOCATION)
+    get_filename_component(target_location "${target_location}" PATH)
+    file(GLOB camera_wrappers "${OpenCV_LIB_DIR}/libnative_camera_r*.so")
+    foreach(wrapper ${camera_wrappers})
+      ADD_CUSTOM_COMMAND(
+        TARGET ${target}
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy "${wrapper}" "${target_location}"
+      )
+    endforeach()
   endmacro()
-ENDIF(ANDROID)
+ENDIF()
 
 # ======================================================
 #  Version variables:
diff --git a/OpenCVFindIPP.cmake b/OpenCVFindIPP.cmake
index 1927454c8b..69f7f2e256 100644
--- a/OpenCVFindIPP.cmake
+++ b/OpenCVFindIPP.cmake
@@ -43,6 +43,14 @@ set(IPPCV      "cv")   # computer vision
 set(IPPVM      "vm")   # vector math
 
 
+set(IPP_X64 0)
+if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+    set(IPP_X64 1)
+endif()
+if (CMAKE_CL_64)
+    set(IPP_X64 1)
+endif()
+
 # ------------------------------------------------------------------------
 # This function detect IPP version by analyzing ippversion.h file
 # Note, ippversion.h file was inroduced since IPP 5.3
@@ -96,7 +104,7 @@ function(set_ipp_old_libraries)
     set(IPPCV      "cv")       # computer vision
     set(IPPVM      "vm")       # vector math
     
-    if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+    if (IPP_X64)
         set(IPP_ARCH "em64t")
     endif()
 
@@ -167,7 +175,7 @@ function(set_ipp_variables _LATEST_VERSION)
         set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE)
         set(IPP_LIBRARY_DIRS ${IPP_ROOT_DIR}/lib     PARENT_SCOPE)
 
-        if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+        if (IPP_X64)
             if(NOT EXISTS ${IPP_ROOT_DIR}/../em64t)
                 message(SEND_ERROR "IPP EM64T libraries not found")
             endif()
@@ -188,7 +196,7 @@ function(set_ipp_variables _LATEST_VERSION)
         # set INCLUDE and LIB folders
         set(IPP_INCLUDE_DIRS ${IPP_ROOT_DIR}/include PARENT_SCOPE)
 
-        if (CMAKE_CXX_SIZEOF_DATA_PTR EQUAL 8)
+        if (IPP_X64)
             if(NOT EXISTS ${IPP_ROOT_DIR}/lib/intel64)
                 message(SEND_ERROR "IPP EM64T libraries not found")
             endif()
diff --git a/OpenCVFindLATEX.cmake b/OpenCVFindLATEX.cmake
index 392d2a8bf2..081f47853d 100644
--- a/OpenCVFindLATEX.cmake
+++ b/OpenCVFindLATEX.cmake
@@ -47,55 +47,55 @@ IF (WIN32)
 
 ENDIF (WIN32)
 
-FIND_PROGRAM(LATEX_COMPILER
+FIND_HOST_PROGRAM(LATEX_COMPILER
   NAMES latex
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
-FIND_PROGRAM(PDFLATEX_COMPILER
+FIND_HOST_PROGRAM(PDFLATEX_COMPILER
   NAMES pdflatex
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
-FIND_PROGRAM(BIBTEX_COMPILER
+FIND_HOST_PROGRAM(BIBTEX_COMPILER
   NAMES bibtex
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
-FIND_PROGRAM(MAKEINDEX_COMPILER
+FIND_HOST_PROGRAM(MAKEINDEX_COMPILER
   NAMES makeindex
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
-FIND_PROGRAM(DVIPS_CONVERTER
+FIND_HOST_PROGRAM(DVIPS_CONVERTER
   NAMES dvips
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
-FIND_PROGRAM(DVIPDF_CONVERTER
+FIND_HOST_PROGRAM(DVIPDF_CONVERTER
   NAMES dvipdfm dvipdft dvipdf
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
 )
 
 IF (WIN32)
-  FIND_PROGRAM(PS2PDF_CONVERTER
+  FIND_HOST_PROGRAM(PS2PDF_CONVERTER
     NAMES ps2pdf14.bat
     PATHS ${GHOSTSCRIPT_LIBRARY_PATH}
   )
 ELSE (WIN32)
-  FIND_PROGRAM(PS2PDF_CONVERTER
+  FIND_HOST_PROGRAM(PS2PDF_CONVERTER
     NAMES ps2pdf14 ps2pdf
     PATHS /usr/bin /usr/texbin
   )
 ENDIF (WIN32)
 
-FIND_PROGRAM(LATEX2HTML_CONVERTER
+FIND_HOST_PROGRAM(LATEX2HTML_CONVERTER
   NAMES latex2html
   PATHS ${MIKTEX_BINARY_PATH}
         /usr/bin /usr/texbin
diff --git a/OpenCVFindOpenNI.cmake b/OpenCVFindOpenNI.cmake
index 17ad9cca15..2bfd074daa 100644
--- a/OpenCVFindOpenNI.cmake
+++ b/OpenCVFindOpenNI.cmake
@@ -2,81 +2,57 @@
 # OPENNI_LIBRARY and OPENNI_INCLUDES to link OpenCV modules with OpenNI
 # HAVE_OPENNI for conditional compilation OpenCV with/without OpenNI
 
-set(OPENNI_LIB_DESCR "Path to the directory of OpenNI libraries" CACHE INTERNAL "Description" )
-set(OPENNI_INCLUDE_DESCR "Path to the directory of OpenNI includes" CACHE INTERNAL "Description" )
-set(OPENNI_PRIME_SENSOR_MODULE_BIN_DESCR "Path to the directory of PrimeSensor Module binaries" CACHE INTERNAL "Description" )
-
 if(NOT "${OPENNI_LIB_DIR}" STREQUAL "${OPENNI_LIB_DIR_INTERNAL}")
     unset(OPENNI_LIBRARY CACHE)
-endif()
-	
-if(NOT "${OPENNI_INCLUDE_DIR}" STREQUAL "${OPENNI_INCLUDE_DIR_INTERNAL}")
-    unset(OPENNI_INCLUDES CACHE)
-endif()
-	
-if(NOT "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" STREQUAL "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}")
-    unset(OPENNI_PRIME_SENSOR_MODULE CACHE)
-endif()
-	
-if(NOT OPENNI_LIB_DIR OR OPENNI_LIB_DIR STREQUAL "")
-    if(WIN32)
-        set(OPENNI_LIB_DIR "c:/Program Files/OpenNI/Lib" CACHE PATH ${OPENNI_LIB_DESCR})
-    elseif(UNIX OR APPLE)
-        set(OPENNI_LIB_DIR "/usr/lib" CACHE PATH ${OPENNI_LIB_DESCR})
-    endif()
-endif()
-	
-if(NOT OPENNI_INCLUDE_DIR OR OPENNI_INCLUDE_DIR STREQUAL "")
-    if(WIN32)
-        set(OPENNI_INCLUDE_DIR "c:/Program Files/OpenNI/Include" CACHE PATH ${OPENNI_INCLUDE_DESCR})
-    elseif(UNIX OR APPLE)
-        set(OPENNI_INCLUDE_DIR "/usr/include/ni" CACHE PATH ${OPENNI_INCLUDE_DESCR})
-    endif()
-endif()
-	
-if(NOT OPENNI_PRIME_SENSOR_MODULE_BIN_DIR OR OPENNI_PRIME_SENSOR_MODULE_BIN_DIR STREQUAL "")
-    if(WIN32)
-        set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "c:/Program Files/Prime Sense/Sensor/Bin" CACHE PATH ${OPENNI_PRIME_SENSOR_MODULE_BIN_DESCR})
-    elseif(UNIX OR APPLE)
-        set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "/usr/lib" CACHE PATH ${OPENNI_PRIME_SENSOR_MODULE_BIN_DESCR})
-    endif()
+    unset(OPENNI_LIB_DIR CACHE)
 endif()
 
-find_library(OPENNI_LIBRARY "OpenNI" PATHS ${OPENNI_LIB_DIR} DOC "OpenNI library" NO_DEFAULT_PATH)
-find_path(OPENNI_INCLUDES "XnCppWrapper.h" PATHS ${OPENNI_INCLUDE_DIR} DOC "OpenNI c++ interface header" NO_DEFAULT_PATH)
+if(NOT "${OPENNI_INCLUDE_DIR}" STREQUAL "${OPENNI_INCLUDE_DIR_INTERNAL}")
+    unset(OPENNI_INCLUDES CACHE)
+    unset(OPENNI_INCLUDE_DIR CACHE)
+endif()
+
+if(NOT "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" STREQUAL "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR_INTERNAL}")
+    unset(OPENNI_PRIME_SENSOR_MODULE CACHE)
+    unset(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR CACHE)
+endif()
+
+find_file(OPENNI_INCLUDES "XnCppWrapper.h" PATHS $ENV{OPEN_NI_INCLUDE} "/usr/include/ni" "/usr/include/openni" "c:/Program Files/OpenNI/Include" DOC "OpenNI c++ interface header")
+find_library(OPENNI_LIBRARY "OpenNI" PATHS $ENV{OPEN_NI_LIB} "/usr/lib" "c:/Program Files/OpenNI/Lib" DOC "OpenNI library")
 
 if(OPENNI_LIBRARY AND OPENNI_INCLUDES)
     set(HAVE_OPENNI TRUE)
-    # the check: are PrimeSensor Modules for OpenNI installed?
+    # the check: are PrimeSensor Modules for OpenNI installed
     if(WIN32)
-        find_file(OPENNI_PRIME_SENSOR_MODULE "XnCore.dll" PATHS ${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR} DOC "Core library of PrimeSensor Modules for OpenNI" NO_DEFAULT_PATH)
+        find_file(OPENNI_PRIME_SENSOR_MODULE "XnCore.dll" PATHS "c:/Program Files/Prime Sense/Sensor/Bin" DOC "Core library of PrimeSensor Modules for OpenNI")
     elseif(UNIX OR APPLE)
-        find_library(OPENNI_PRIME_SENSOR_MODULE "XnCore" PATHS ${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR} DOC "Core library of PrimeSensor Modules for OpenNI" NO_DEFAULT_PATH)
+        find_library(OPENNI_PRIME_SENSOR_MODULE "XnCore" PATHS "/usr/lib" DOC "Core library of PrimeSensor Modules for OpenNI")
     endif()
 	
     if(OPENNI_PRIME_SENSOR_MODULE)
         set(HAVE_OPENNI_PRIME_SENSOR_MODULE TRUE)
-     endif()
+    endif()
 endif() #if(OPENNI_LIBRARY AND OPENNI_INCLUDES)
 
+get_filename_component(OPENNI_LIB_DIR "${OPENNI_LIBRARY}" PATH CACHE)
+get_filename_component(OPENNI_INCLUDE_DIR ${OPENNI_INCLUDES} PATH CACHE)
+get_filename_component(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "${OPENNI_PRIME_SENSOR_MODULE}" PATH CACHE)
+
 if(OPENNI_LIBRARY)
     set(OPENNI_LIB_DIR_INTERNAL "${OPENNI_LIB_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_LIB_DIR was set successfully." FORCE)
 else()
-    set(OPENNI_LIB_DIR "${OPENNI_LIB_DIR}-NOTFOUND or does not have OpenNI libraries" CACHE PATH ${OPENNI_LIB_DESCR} FORCE)
     message( WARNING, " OpenNI library directory (set by OPENNI_LIB_DIR variable) is not found or does not have OpenNI libraries." )
 endif()
 
 if(OPENNI_INCLUDES)
     set(OPENNI_INCLUDE_DIR_INTERNAL "${OPENNI_INCLUDE_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_INCLUDE_DIR was set successfully." FORCE)
 else()
-    set(OPENNI_INCLUDE_DIR "${OPENNI_INCLUDE_DIR}-NOTFOUND or does not have OpenNI includes" CACHE PATH ${OPENNI_INCLUDE_DESCR} FORCE)
-    message( WARNING, " OpenNI include directory (set by OPENNI_INCLUDE_DIR variable) is not found or does not have OpenNI includes." )
+    message( WARNING, " OpenNI include directory (set by OPENNI_INCLUDE_DIR variable) is not found or does not have OpenNI include files." )
 endif()
 
 if(OPENNI_PRIME_SENSOR_MODULE)
     set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR_INTERNAL "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_PRIME_SENSOR_MODULE_BIN_DIR was set successfully." FORCE)
 else()
-    set(OPENNI_PRIME_SENSOR_MODULE_BIN_DIR "${OPENNI_PRIME_SENSOR_MODULE_BIN_DIR}-NOTFOUND or does not have PrimeSensor Module binaries" CACHE PATH ${OPENNI_PRIME_SENSOR_MODULE_BIN_DESCR} FORCE)
     message( WARNING, " PrimeSensor Module binaries directory (set by OPENNI_PRIME_SENSOR_MODULE_BIN_DIR variable) is not found or does not have PrimeSensor Module binaries." )
 endif()
 
diff --git a/OpenCVFindXimea.cmake b/OpenCVFindXimea.cmake
new file mode 100755
index 0000000000..afc73e09f7
--- /dev/null
+++ b/OpenCVFindXimea.cmake
@@ -0,0 +1,35 @@
+# - Find XIMEA
+# This module finds if XIMEA Software package is installed
+# and determines where the binaries and header files are.
+# This code sets the following variables:
+#  
+#  XIMEA_FOUND          - True if XIMEA API found
+#  XIMEA_PATH:          - Path to the XIMEA API folder
+#  XIMEA_LIBRARY_DIRS   - XIMEA libraries folder
+#
+# Created: 5 Aug 2011 by Marian Zajko (marian.zajko@ximea.com)
+#
+
+set(XIMEA_FOUND)
+set(XIMEA_PATH)
+set(XIMEA_LIBRARY_DIR)
+
+# Try to find the XIMEA API path in registry.
+GET_FILENAME_COMPONENT(XIMEA_PATH "[HKEY_CURRENT_USER\\Software\\XIMEA\\CamSupport\\API;Path]" ABSOLUTE)                                                
+
+if(XIMEA_PATH)
+  set(XIMEA_FOUND 1)
+  
+  # set LIB folders
+  set(XIMEA_LIBRARY_DIR "${XIMEA_PATH}\\x86")
+  
+else()
+  set(XIMEA_FOUND 0)
+endif()                                            
+
+mark_as_advanced(FORCE XIMEA_FOUND)
+mark_as_advanced(FORCE XIMEA_PATH)
+mark_as_advanced(FORCE XIMEA_LIBRARY_DIR)
+  
+   
+   
\ No newline at end of file
diff --git a/OpenCVModule.cmake b/OpenCVModule.cmake
index f7620b6cb9..53a24bdfdc 100644
--- a/OpenCVModule.cmake
+++ b/OpenCVModule.cmake
@@ -1,3 +1,24 @@
+#opencv precompiled headers macro (can add pch to modules and tests)
+#this macro must be called after any "add_definitions" commands, otherwise precompiled headers will not work
+macro(add_opencv_precompiled_headers the_target)
+    if("${the_target}" MATCHES "opencv_test_.*")
+        SET(pch_name "test/test_precomp")
+    else()
+        SET(pch_name "src/precomp")
+    endif()
+    set(pch_header "${CMAKE_CURRENT_SOURCE_DIR}/${pch_name}.hpp")
+    if(PCHSupport_FOUND AND USE_PRECOMPILED_HEADERS AND EXISTS "${pch_header}")
+        if(CMAKE_GENERATOR MATCHES Visual)
+            set(${the_target}_pch "${CMAKE_CURRENT_SOURCE_DIR}/${pch_name}.cpp")
+            add_native_precompiled_header(${the_target} ${pch_header})
+        elseif(CMAKE_GENERATOR MATCHES Xcode)
+            add_native_precompiled_header(${the_target} ${pch_header})
+        elseif(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_GENERATOR MATCHES Makefiles)
+            add_precompiled_header(${the_target} ${pch_header})
+        endif()
+    endif()
+endmacro()
+
 # this is template for a OpenCV module 
 macro(define_opencv_module name)
     
@@ -8,20 +29,19 @@ macro(define_opencv_module name)
                         "${CMAKE_CURRENT_BINARY_DIR}")
     
     foreach(d ${ARGN})
-        if(${d} MATCHES "opencv_")
-            if(${d} MATCHES "opencv_lapack")
-            else()
-                string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
-                include_directories("${d_dir}/include")
-            endif()
+        if(d MATCHES "opencv_")
+            string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
+            include_directories("${d_dir}/include")
         endif()
     endforeach()
 
     file(GLOB lib_srcs "src/*.cpp")
     file(GLOB lib_int_hdrs "src/*.h*")
+
     if(COMMAND get_module_external_sources)
        get_module_external_sources(${name})
     endif()
+
     source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
 
     file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")
@@ -66,17 +86,7 @@ macro(define_opencv_module name)
         INSTALL_NAME_DIR lib
         )
 
-    if(PCHSupport_FOUND AND USE_PRECOMPILED_HEADERS)
-        set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
-        if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-            if(${CMAKE_GENERATOR} MATCHES "Visual*")
-                set(${the_target}_pch "src/precomp.cpp")
-            endif()            
-            add_native_precompiled_header(${the_target} ${pch_header})
-        elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-            add_precompiled_header(${the_target} ${pch_header})
-        endif()
-    endif()
+    add_opencv_precompiled_headers(${the_target})
 
     # Add the required libraries for linking:
     target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
@@ -97,11 +107,11 @@ macro(define_opencv_module name)
 
     install(TARGETS ${the_target}
         RUNTIME DESTINATION bin COMPONENT main
-        LIBRARY DESTINATION lib COMPONENT main
-        ARCHIVE DESTINATION lib COMPONENT main)
+        LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
+        ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 
     install(FILES ${lib_hdrs}
-        DESTINATION include/opencv2/${name}
+        DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/${name}
         COMPONENT main)
         
     if(BUILD_TESTS AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
@@ -111,12 +121,9 @@ macro(define_opencv_module name)
 
         set(test_deps opencv_${name} ${ARGN} opencv_ts opencv_highgui ${EXTRA_${the_target}_DEPS})
         foreach(d ${test_deps})
-            if(${d} MATCHES "opencv_")
-                if(${d} MATCHES "opencv_lapack")
-                else()
-                    string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
-                    include_directories("${d_dir}/include")
-                endif()
+            if(d MATCHES "opencv_")
+                string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
+                include_directories("${d_dir}/include")
             endif()
         endforeach()
 
@@ -130,24 +137,14 @@ macro(define_opencv_module name)
 
         add_executable(${the_target} ${test_srcs} ${test_hdrs})
 
-        if(PCHSupport_FOUND AND USE_PRECOMPILED_HEADERS)
-            set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/test/test_precomp.hpp)
-            if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-                if(${CMAKE_GENERATOR} MATCHES "Visual*")
-                    set(${the_target}_pch "test/test_precomp.cpp")
-                endif()            
-                add_native_precompiled_header(${the_target} ${pch_header})
-            elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-                add_precompiled_header(${the_target} ${pch_header})
-            endif()
-        endif()
+        add_opencv_precompiled_headers(${the_target})
 
         # Additional target properties
         set_target_properties(${the_target} PROPERTIES
             DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
             RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
             )
-            
+
         if(ENABLE_SOLUTION_FOLDERS)
             set_target_properties(${the_target} PROPERTIES FOLDER "tests")
         endif() 
@@ -165,5 +162,5 @@ macro(define_opencv_module name)
         #    install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
         #endif()
     endif()    
-        
+
 endmacro()
diff --git a/OpenCVPCHSupport.cmake b/OpenCVPCHSupport.cmake
index b72783fa80..0955255dad 100644
--- a/OpenCVPCHSupport.cmake
+++ b/OpenCVPCHSupport.cmake
@@ -15,234 +15,234 @@
 IF(CMAKE_COMPILER_IS_GNUCXX)
 
     EXEC_PROGRAM(
-    	${CMAKE_CXX_COMPILER}
-        ARGS 	${CMAKE_CXX_COMPILER_ARG1} -dumpversion
+        ${CMAKE_CXX_COMPILER}
+        ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
         OUTPUT_VARIABLE gcc_compiler_version)
     #MESSAGE("GCC Version: ${gcc_compiler_version}")
     IF(gcc_compiler_version MATCHES "4\\.[0,2-9]\\.[0-9]")
         SET(PCHSupport_FOUND TRUE)
     ENDIF()
 
-	SET(_PCH_include_prefix "-I")
+    SET(_PCH_include_prefix "-I")
 
+ELSEIF(WIN32)
+    SET(PCHSupport_FOUND TRUE) # for experimental msvc support
+    SET(_PCH_include_prefix "/I")
 ELSE()
-	IF(WIN32)
-		SET(PCHSupport_FOUND TRUE) # for experimental msvc support
-		SET(_PCH_include_prefix "/I")
-	ELSE()
-		SET(PCHSupport_FOUND FALSE)
-	ENDIF()
-ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+    SET(PCHSupport_FOUND FALSE)
+ENDIF()
 
 MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
 
+    STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _flags_var_name)
+    SET(${_out_compile_flags} ${${_flags_var_name}} )
 
-  STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _flags_var_name)
-  SET(${_out_compile_flags} ${${_flags_var_name}} )
+    IF(CMAKE_COMPILER_IS_GNUCXX)
 
-  IF(CMAKE_COMPILER_IS_GNUCXX)
+        GET_TARGET_PROPERTY(_targetType ${_PCH_current_target} TYPE)
+        IF(${_targetType} STREQUAL SHARED_LIBRARY AND NOT WIN32)
+            LIST(APPEND ${_out_compile_flags} "-fPIC")
+        ENDIF()
 
-    GET_TARGET_PROPERTY(_targetType ${_PCH_current_target} TYPE)
-    IF(${_targetType} STREQUAL SHARED_LIBRARY AND NOT WIN32)
-    	LIST(APPEND ${_out_compile_flags} "${${_out_compile_flags}} -fPIC")
+    ELSE()
+        ## TODO ... ? or does it work out of the box
     ENDIF()
 
-  ELSE()
-    ## TODO ... ? or does it work out of the box
-  ENDIF()
+    GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )
+    FOREACH(item ${DIRINC})
+        LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
+    ENDFOREACH(item)
 
-  GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES )
-  FOREACH(item ${DIRINC})
-    LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}${item}")
-  ENDFOREACH(item)
+    GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
+    GET_DIRECTORY_PROPERTY(_global_definitions DIRECTORY ${OpenCV_SOURCE_DIR} DEFINITIONS)
+    #MESSAGE("_directory_flags ${_directory_flags} ${_global_definitions}" )
+    LIST(APPEND ${_out_compile_flags} ${_directory_flags})
+    LIST(APPEND ${_out_compile_flags} ${_global_definitions})
+    LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS})
 
-  GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
-  GET_DIRECTORY_PROPERTY(_global_definitions DIRECTORY ${OpenCV_SOURCE_DIR} DEFINITIONS)
-  #MESSAGE("_directory_flags ${_directory_flags} ${_global_definitions}" )
-  LIST(APPEND ${_out_compile_flags} ${_directory_flags})
-  LIST(APPEND ${_out_compile_flags} ${_global_definitions})
-  LIST(APPEND ${_out_compile_flags} ${CMAKE_CXX_FLAGS} )
-
-  SEPARATE_ARGUMENTS(${_out_compile_flags})
+    SEPARATE_ARGUMENTS(${_out_compile_flags})
 
 ENDMACRO(_PCH_GET_COMPILE_FLAGS)
 
 
 MACRO(_PCH_WRITE_PCHDEP_CXX _targetName _include_file _dephelp)
 
-  SET(${_dephelp} ${CMAKE_CURRENT_BINARY_DIR}/${_targetName}_pch_dephelp.cxx)
-  FILE(WRITE  ${${_dephelp}}
-"#include \"${_include_file}\"
-int testfunction()
-{
-    return 0;
-}
-"
-    )
+    SET(${_dephelp} ${CMAKE_CURRENT_BINARY_DIR}/${_targetName}_pch_dephelp.cxx)
+    IF(CMAKE_HOST_WIN32)
+        ADD_CUSTOM_COMMAND(
+          OUTPUT "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "#include \\\"${_include_file}\\\"" >  "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "int testfunction()"                >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "{"                                 >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "    return 0;"                     >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "}"                                 >> "${${_dephelp}}"
+          DEPENDS "${_include_file}"
+          )
+    else()
+        ADD_CUSTOM_COMMAND(
+          OUTPUT "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "\\#include \\\"${_include_file}\\\"" >  "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "int testfunction\\(\\)"            >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "{"                                 >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "    \\return 0\\;"                 >> "${${_dephelp}}"
+          COMMAND ${CMAKE_COMMAND} -E echo "}"                                 >> "${${_dephelp}}"
+          DEPENDS "${_include_file}"
+          )
+    endif()
 
 ENDMACRO(_PCH_WRITE_PCHDEP_CXX )
 
 MACRO(_PCH_GET_COMPILE_COMMAND out_command _input _output)
 
-	FILE(TO_NATIVE_PATH ${_input} _native_input)
-	FILE(TO_NATIVE_PATH ${_output} _native_output)
+    FILE(TO_NATIVE_PATH ${_input} _native_input)
+    FILE(TO_NATIVE_PATH ${_output} _native_output)
 
-
-	IF(CMAKE_COMPILER_IS_GNUCXX)
-          IF(CMAKE_CXX_COMPILER_ARG1)
-	    # remove leading space in compiler argument
+    IF(CMAKE_COMPILER_IS_GNUCXX)
+        IF(CMAKE_CXX_COMPILER_ARG1)
+            # remove leading space in compiler argument
             STRING(REGEX REPLACE "^ +" "" pchsupport_compiler_cxx_arg1 ${CMAKE_CXX_COMPILER_ARG1})
 
-	    SET(${out_command}
-	      ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS}	-x c++-header -o ${_output} ${_input}
-	      )
-	  ELSE(CMAKE_CXX_COMPILER_ARG1)
-	    SET(${out_command}
-	      ${CMAKE_CXX_COMPILER}  ${_compile_FLAGS}	-x c++-header -o ${_output} ${_input}
-	      )
-          ENDIF(CMAKE_CXX_COMPILER_ARG1)
-	ELSE(CMAKE_COMPILER_IS_GNUCXX)
+            SET(${out_command}
+              ${CMAKE_CXX_COMPILER} ${pchsupport_compiler_cxx_arg1} ${_compile_FLAGS} -x c++-header -o ${_output} ${_input}
+              )
+        ELSE(CMAKE_CXX_COMPILER_ARG1)
+            SET(${out_command}
+              ${CMAKE_CXX_COMPILER}  ${_compile_FLAGS} -x c++-header -o ${_output} ${_input}
+              )
+        ENDIF(CMAKE_CXX_COMPILER_ARG1)
+    ELSE(CMAKE_COMPILER_IS_GNUCXX)
 
-		SET(_dummy_str "#include <${_input}>")
-		FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/pch_dummy.cpp ${_dummy_str})
+        SET(_dummy_str "#include <${_input}>")
+        FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/pch_dummy.cpp ${_dummy_str})
 
-		SET(${out_command}
-			${CMAKE_CXX_COMPILER} ${_compile_FLAGS} /c /Fp${_native_output} /Yc${_native_input} pch_dummy.cpp
-		)
-		#/out:${_output}
+        SET(${out_command}
+          ${CMAKE_CXX_COMPILER} ${_compile_FLAGS} /c /Fp${_native_output} /Yc${_native_input} pch_dummy.cpp
+          )
+        #/out:${_output}
 
-	ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+    ENDIF(CMAKE_COMPILER_IS_GNUCXX)
 
 ENDMACRO(_PCH_GET_COMPILE_COMMAND )
 
 
-
 MACRO(_PCH_GET_TARGET_COMPILE_FLAGS _cflags  _header_name _pch_path _dowarn )
 
-  FILE(TO_NATIVE_PATH ${_pch_path} _native_pch_path)
+    FILE(TO_NATIVE_PATH ${_pch_path} _native_pch_path)
 
-  IF(CMAKE_COMPILER_IS_GNUCXX)
-    # for use with distcc and gcc >4.0.1 if preprocessed files are accessible
-    # on all remote machines set
-    # PCH_ADDITIONAL_COMPILER_FLAGS to -fpch-preprocess
-    # if you want warnings for invalid header files (which is very inconvenient
-    # if you have different versions of the headers for different build types
-    # you may set _pch_dowarn
-    IF (_dowarn)
-      SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include ${CMAKE_CURRENT_BINARY_DIR}/${_header_name} -Winvalid-pch " )
-    ELSE (_dowarn)
-      SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include ${CMAKE_CURRENT_BINARY_DIR}/${_header_name} " )
-    ENDIF (_dowarn)
-  ELSE(CMAKE_COMPILER_IS_GNUCXX)
+    IF(CMAKE_COMPILER_IS_GNUCXX)
+        # for use with distcc and gcc >4.0.1 if preprocessed files are accessible
+        # on all remote machines set
+        # PCH_ADDITIONAL_COMPILER_FLAGS to -fpch-preprocess
+        # if you want warnings for invalid header files (which is very inconvenient
+        # if you have different versions of the headers for different build types
+        # you may set _pch_dowarn
+        IF (_dowarn)
+            SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" -Winvalid-pch " )
+        ELSE (_dowarn)
+            SET(${_cflags} "${PCH_ADDITIONAL_COMPILER_FLAGS} -include \"${CMAKE_CURRENT_BINARY_DIR}/${_header_name}\" " )
+        ENDIF (_dowarn)
 
-    set(${_cflags} "/Fp${_native_pch_path} /Yu${_header_name}" )
+    ELSE(CMAKE_COMPILER_IS_GNUCXX)
 
-  ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+        set(${_cflags} "/Fp${_native_pch_path} /Yu${_header_name}" )
+
+    ENDIF(CMAKE_COMPILER_IS_GNUCXX)
 
 ENDMACRO(_PCH_GET_TARGET_COMPILE_FLAGS )
 
+
 MACRO(GET_PRECOMPILED_HEADER_OUTPUT _targetName _input _output)
-  GET_FILENAME_COMPONENT(_name ${_input} NAME)
-  GET_FILENAME_COMPONENT(_path ${_input} PATH)
-  SET(_output "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gch/${_targetName}_${CMAKE_BUILD_TYPE}.gch")
+
+    GET_FILENAME_COMPONENT(_name ${_input} NAME)
+    GET_FILENAME_COMPONENT(_path ${_input} PATH)
+    SET(${_output} "${CMAKE_CURRENT_BINARY_DIR}/${_name}.gch/${_targetName}_${CMAKE_BUILD_TYPE}.gch")
+
 ENDMACRO(GET_PRECOMPILED_HEADER_OUTPUT _targetName _input)
 
 
 MACRO(ADD_PRECOMPILED_HEADER_TO_TARGET _targetName _input _pch_output_to_use )
 
-  # to do: test whether compiler flags match between target  _targetName
-  # and _pch_output_to_use
-  GET_FILENAME_COMPONENT(_name ${_input} NAME)
+    # to do: test whether compiler flags match between target  _targetName
+    # and _pch_output_to_use
+    GET_FILENAME_COMPONENT(_name ${_input} NAME)
 
-  IF( "${ARGN}" STREQUAL "0")
-    SET(_dowarn 0)
-  ELSE( "${ARGN}" STREQUAL "0")
-    SET(_dowarn 1)
-  ENDIF("${ARGN}" STREQUAL "0")
+    IF(ARGN STREQUAL "0")
+        SET(_dowarn 0)
+    ELSE()
+        SET(_dowarn 1)
+    ENDIF()
 
+    _PCH_GET_TARGET_COMPILE_FLAGS(_target_cflags ${_name} ${_pch_output_to_use} ${_dowarn})
+    #MESSAGE("Add flags ${_target_cflags} to ${_targetName} " )
+    SET_TARGET_PROPERTIES(${_targetName}
+      PROPERTIES
+      COMPILE_FLAGS ${_target_cflags}
+      )
 
-  _PCH_GET_TARGET_COMPILE_FLAGS(_target_cflags ${_name} ${_pch_output_to_use} ${_dowarn})
-  #   MESSAGE("Add flags ${_target_cflags} to ${_targetName} " )
-  SET_TARGET_PROPERTIES(${_targetName}
-    PROPERTIES
-    COMPILE_FLAGS ${_target_cflags}
-    )
+    ADD_CUSTOM_TARGET(pch_Generate_${_targetName}
+      DEPENDS ${_pch_output_to_use}
+      )
 
-  ADD_CUSTOM_TARGET(pch_Generate_${_targetName}
-    DEPENDS	${_pch_output_to_use}
-    )
-
-  ADD_DEPENDENCIES(${_targetName} pch_Generate_${_targetName} )
+    ADD_DEPENDENCIES(${_targetName} pch_Generate_${_targetName} )
 
 ENDMACRO(ADD_PRECOMPILED_HEADER_TO_TARGET)
 
 MACRO(ADD_PRECOMPILED_HEADER _targetName _input)
 
-  SET(_PCH_current_target ${_targetName})
+    SET(_PCH_current_target ${_targetName})
 
-  IF(NOT CMAKE_BUILD_TYPE)
-    MESSAGE(FATAL_ERROR
-      "This is the ADD_PRECOMPILED_HEADER macro. "
-      "You must set CMAKE_BUILD_TYPE!"
-      )
-  ENDIF(NOT CMAKE_BUILD_TYPE)
+    IF(NOT CMAKE_BUILD_TYPE)
+        MESSAGE(FATAL_ERROR
+          "This is the ADD_PRECOMPILED_HEADER macro. "
+          "You must set CMAKE_BUILD_TYPE!"
+          )
+    ENDIF()
 
-  IF( "${ARGN}" STREQUAL "0")
-    SET(_dowarn 0)
-  ELSE( "${ARGN}" STREQUAL "0")
-    SET(_dowarn 1)
-  ENDIF("${ARGN}" STREQUAL "0")
+    IF(ARGN STREQUAL "0")
+        SET(_dowarn 0)
+    ELSE()
+        SET(_dowarn 1)
+    ENDIF()
 
+    GET_FILENAME_COMPONENT(_name ${_input} NAME)
+    GET_FILENAME_COMPONENT(_path ${_input} PATH)
+    GET_PRECOMPILED_HEADER_OUTPUT( ${_targetName} ${_input} _output)
 
-  GET_FILENAME_COMPONENT(_name ${_input} NAME)
-  GET_FILENAME_COMPONENT(_path ${_input} PATH)
-  GET_PRECOMPILED_HEADER_OUTPUT( ${_targetName} ${_input} _output)
+    _PCH_WRITE_PCHDEP_CXX(${_targetName} "${_input}" _pch_dephelp_cxx)
 
-  GET_FILENAME_COMPONENT(_outdir ${_output} PATH )
-
-  GET_TARGET_PROPERTY(_targetType ${_PCH_current_target} TYPE)
-   _PCH_WRITE_PCHDEP_CXX(${_targetName} ${_input} _pch_dephelp_cxx)
-
-  IF(${_targetType} STREQUAL SHARED_LIBRARY)
-    ADD_LIBRARY(${_targetName}_pch_dephelp STATIC ${_pch_dephelp_cxx} )
-  ELSE(${_targetType} STREQUAL SHARED_LIBRARY)
-    ADD_LIBRARY(${_targetName}_pch_dephelp STATIC ${_pch_dephelp_cxx})
-  ENDIF(${_targetType} STREQUAL SHARED_LIBRARY)
+    ADD_LIBRARY(${_targetName}_pch_dephelp STATIC "${_pch_dephelp_cxx}" "${_input}" )
   
-  set_target_properties(${_targetName}_pch_dephelp PROPERTIES
-    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
-    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/"
-    )
+    set_target_properties(${_targetName}_pch_dephelp PROPERTIES
+      DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+      ARCHIVE_OUTPUT_DIRECTORY "${LIBRARY_OUTPUT_PATH}"
+      )
 
+    _PCH_GET_COMPILE_FLAGS(_compile_FLAGS)
 
-  FILE(MAKE_DIRECTORY ${_outdir})
+    #MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
+    #message("COMMAND ${CMAKE_CXX_COMPILER}	${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")
+    
+    ADD_CUSTOM_COMMAND(
+      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
+      COMMAND ${CMAKE_COMMAND} -E copy  "${_input}" "${CMAKE_CURRENT_BINARY_DIR}/${_name}" # ensure same directory! Required by gcc
+      DEPENDS "${_input}"
+      )
 
+    #message("_command  ${_input} ${_output}")
+    _PCH_GET_COMPILE_COMMAND(_command  ${CMAKE_CURRENT_BINARY_DIR}/${_name} ${_output} )
 
-  _PCH_GET_COMPILE_FLAGS(_compile_FLAGS)
+    GET_FILENAME_COMPONENT(_outdir ${_output} PATH)
+    ADD_CUSTOM_COMMAND(
+      OUTPUT "${_output}"
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${_outdir}"
+      COMMAND ${_command}
+      DEPENDS "${_input}"
+      DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${_name}"
+      DEPENDS ${_targetName}_pch_dephelp
+      )
 
-  #MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
-  #message("COMMAND ${CMAKE_CXX_COMPILER}	${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")
-  SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/${_name} PROPERTIES GENERATED 1)
-  ADD_CUSTOM_COMMAND(
-   OUTPUT	${CMAKE_CURRENT_BINARY_DIR}/${_name}
-   COMMAND ${CMAKE_COMMAND} -E copy  ${_input} ${CMAKE_CURRENT_BINARY_DIR}/${_name} # ensure same directory! Required by gcc
-   DEPENDS ${_input}
-  )
-
-  #message("_command  ${_input} ${_output}")
-  _PCH_GET_COMPILE_COMMAND(_command  ${CMAKE_CURRENT_BINARY_DIR}/${_name} ${_output} )
-
-  #message(${_input} )
-  #message("_output ${_output}")
-
-  ADD_CUSTOM_COMMAND(
-    OUTPUT ${_output}
-    COMMAND ${_command}
-    DEPENDS ${_input}   ${CMAKE_CURRENT_BINARY_DIR}/${_name} ${_targetName}_pch_dephelp
-   )
-
-
-  ADD_PRECOMPILED_HEADER_TO_TARGET(${_targetName} ${_input}  ${_output} ${_dowarn})
+    ADD_PRECOMPILED_HEADER_TO_TARGET(${_targetName} ${_input}  ${_output} ${_dowarn})
+    
 ENDMACRO(ADD_PRECOMPILED_HEADER)
 
 
@@ -253,72 +253,66 @@ ENDMACRO(ADD_PRECOMPILED_HEADER)
 
 MACRO(GET_NATIVE_PRECOMPILED_HEADER _targetName _input)
 
-	if(CMAKE_GENERATOR MATCHES Visual*)
+    if(CMAKE_GENERATOR MATCHES "^Visual.*$")
+        SET(_dummy_str "#include \"${_input}\"\n"
+"// This is required to suppress LNK4221.  Very annoying.\n"
+"void *g_${_targetName}Dummy = 0\;\n")
 
-		SET(_dummy_str "#include \"${_input}\"\n"
-										"// This is required to suppress LNK4221.  Very annoying.\n"
-										"void *g_${_targetName}Dummy = 0\;\n")
-
-		# Use of cxx extension for generated files (as Qt does)
-		SET(${_targetName}_pch ${CMAKE_CURRENT_BINARY_DIR}/${_targetName}_pch.cxx)
-		if(EXISTS ${${_targetName}_pch})
-			# Check if contents is the same, if not rewrite
-			# todo
-		else(EXISTS ${${_targetName}_pch})
-			FILE(WRITE ${${_targetName}_pch} ${_dummy_str})
-		endif(EXISTS ${${_targetName}_pch})
-	endif(CMAKE_GENERATOR MATCHES Visual*)
+        # Use of cxx extension for generated files (as Qt does)
+        SET(${_targetName}_pch ${CMAKE_CURRENT_BINARY_DIR}/${_targetName}_pch.cxx)
+        if(EXISTS ${${_targetName}_pch})
+            # Check if contents is the same, if not rewrite
+            # todo
+        else()
+            FILE(WRITE ${${_targetName}_pch} ${_dummy_str})
+        endif()
+    endif()
 
 ENDMACRO(GET_NATIVE_PRECOMPILED_HEADER)
 
 
 MACRO(ADD_NATIVE_PRECOMPILED_HEADER _targetName _input)
 
-	IF( "${ARGN}" STREQUAL "0")
-		SET(_dowarn 0)
-	ELSE( "${ARGN}" STREQUAL "0")
-		SET(_dowarn 1)
-	ENDIF("${ARGN}" STREQUAL "0")
+    IF(ARGN STREQUAL "0")
+        SET(_dowarn 0)
+    ELSE()
+        SET(_dowarn 1)
+    ENDIF()
 
-	if(CMAKE_GENERATOR MATCHES Visual*)
-		# Auto include the precompile (useful for moc processing, since the use of
-		# precompiled is specified at the target level
-		# and I don't want to specifiy /F- for each moc/res/ui generated files (using Qt)
+    if(CMAKE_GENERATOR MATCHES "^Visual.*$")
+    
+        # Auto include the precompile (useful for moc processing, since the use of
+        # precompiled is specified at the target level
+        # and I don't want to specifiy /F- for each moc/res/ui generated files (using Qt)
 
-		GET_TARGET_PROPERTY(oldProps ${_targetName} COMPILE_FLAGS)
-		if (${oldProps} MATCHES NOTFOUND)
-			SET(oldProps "")
-		endif(${oldProps} MATCHES NOTFOUND)
+        GET_TARGET_PROPERTY(oldProps ${_targetName} COMPILE_FLAGS)
+        if (oldProps MATCHES NOTFOUND)
+            SET(oldProps "")
+        endif()
 
-		SET(newProperties "${oldProps} /Yu\"${_input}\" /FI\"${_input}\"")
-		SET_TARGET_PROPERTIES(${_targetName} PROPERTIES COMPILE_FLAGS "${newProperties}")
+        SET(newProperties "${oldProps} /Yu\"${_input}\" /FI\"${_input}\"")
+        SET_TARGET_PROPERTIES(${_targetName} PROPERTIES COMPILE_FLAGS "${newProperties}")
 
-		#also inlude ${oldProps} to have the same compile options
-		SET_SOURCE_FILES_PROPERTIES(${${_targetName}_pch} PROPERTIES COMPILE_FLAGS "${oldProps} /Yc\"${_input}\"")
+        #also inlude ${oldProps} to have the same compile options
+        SET_SOURCE_FILES_PROPERTIES(${${_targetName}_pch} PROPERTIES COMPILE_FLAGS "${oldProps} /Yc\"${_input}\"")
 
-	else(CMAKE_GENERATOR MATCHES Visual*)
+    elseif (CMAKE_GENERATOR MATCHES Xcode)
+    
+        # For Xcode, cmake needs my patch to process
+        # GCC_PREFIX_HEADER and GCC_PRECOMPILE_PREFIX_HEADER as target properties
 
-		if (CMAKE_GENERATOR MATCHES Xcode)
-			# For Xcode, cmake needs my patch to process
-			# GCC_PREFIX_HEADER and GCC_PRECOMPILE_PREFIX_HEADER as target properties
+        # When buiding out of the tree, precompiled may not be located
+        # Use full path instead.
+        GET_FILENAME_COMPONENT(fullPath ${_input} ABSOLUTE)
 
-			GET_TARGET_PROPERTY(oldProps ${_targetName} COMPILE_FLAGS)
-			if (${oldProps} MATCHES NOTFOUND)
-				SET(oldProps "")
-			endif(${oldProps} MATCHES NOTFOUND)
+        SET_TARGET_PROPERTIES(${_targetName} PROPERTIES XCODE_ATTRIBUTE_GCC_PREFIX_HEADER "${fullPath}")
+        SET_TARGET_PROPERTIES(${_targetName} PROPERTIES XCODE_ATTRIBUTE_GCC_PRECOMPILE_PREFIX_HEADER "YES")
 
-			# When buiding out of the tree, precompiled may not be located
-			# Use full path instead.
-			GET_FILENAME_COMPONENT(fullPath ${_input} ABSOLUTE)
+    else()
 
-			SET_TARGET_PROPERTIES(${_targetName} PROPERTIES XCODE_ATTRIBUTE_GCC_PREFIX_HEADER "${fullPath}")
-			SET_TARGET_PROPERTIES(${_targetName} PROPERTIES XCODE_ATTRIBUTE_GCC_PRECOMPILE_PREFIX_HEADER "YES")
+        #Fallback to the "old" precompiled suppport
+        #ADD_PRECOMPILED_HEADER(${_targetName} ${_input} ${_dowarn})
 
-		else (CMAKE_GENERATOR MATCHES Xcode)
-
-			#Fallback to the "old" precompiled suppport
-			#ADD_PRECOMPILED_HEADER(${_targetName} ${_input} ${_dowarn})
-		endif(CMAKE_GENERATOR MATCHES Xcode)
-	endif(CMAKE_GENERATOR MATCHES Visual*)
+    endif()
 
 ENDMACRO(ADD_NATIVE_PRECOMPILED_HEADER)
diff --git a/Package.cmake.in b/Package.cmake.in
deleted file mode 100644
index f97868d241..0000000000
--- a/Package.cmake.in
+++ /dev/null
@@ -1,111 +0,0 @@
-#
-# CPack template for OpenCV
-#
-# (c) Copyrights 2008 Hartmut Seichter, HIT Lab NZ
-#
-
-if(MSVC)
-    set(CMAKE_INSTALL_DEBUG_LIBRARIES 1)
-endif()
-#if(ENABLE_OPENMP)
-#    set(CMAKE_INSTALL_OPENMP_LIBRARIES 1)
-#endif()
-include(InstallRequiredSystemLibraries)
-
-set(CPACK_PACKAGE_NAME "OpenCV")
-set(CPACK_PACKAGE_VENDOR "OpenCV project opencvlibrary.sourceforge.net")
-
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "OpenCV SDK for ${CMAKE_GENERATOR} is an All-In-One package for developing computer vision applications")
-
-#set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README")
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/doc/license.txt")
-
-set(CPACK_PACKAGE_VERSION_MAJOR "${OPENCV_VERSION_MAJOR}")
-set(CPACK_PACKAGE_VERSION_MINOR "${OPENCV_VERSION_MINOR}")
-set(CPACK_PACKAGE_VERSION_PATCH "${OPENCV_VERSION_PATCH}")
-
-set(CPACK_PACKAGE_INSTALL_DIRECTORY "OpenCV${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}")
-
-set(CPACK_PACKAGE_EXECUTABLES "")
-
-set(CPACK_COMPONENTS_ALL main src Unspecified)
-
-set(CPACK_COMPONENT_main_DISPLAY_NAME "Binaries and the Documentation")
-set(CPACK_COMPONENT_src_DISPLAY_NAME "The source code")
-#set(CPACK_COMPONENT_py_DISPLAY_NAME "Python Bindings")
-
-set(CPACK_ALL_INSTALL_TYPES Full)
-
-set(CPACK_COMPONENT_MAIN_INSTALL_TYPES Full)
-set(CPACK_COMPONENT_SRC_INSTALL_TYPES Full)
-#set(CPACK_COMPONENT_py_INSTALL_TYPES Full)
-
-set(CPACK_SOURCE_IGNORE_FILES
-    "/\\\\.svn/"
-    "/autom4te.cache/"
-    "/build/"
-    "/interfaces/"
-    "/swig_python/"
-    "/octave/"
-    "/gtest/"
-    "~$"    
-    "\\\\.aux$"
-    "\\\\.bbl$"
-    "\\\\.blg$"
-    "\\\\.idx$"
-    "\\\\.ilg$"
-    "\\\\.ind$"
-    "\\\\.log$"
-    "\\\\.toc$"
-    "\\\\.out$"
-    "\\\\.pyc$"
-    "\\\\.pyo$"
-    "\\\\.vcproj$"
-    "/1$"
-    "${CPACK_SOURCE_IGNORE_FILES}")
-
-if(NOT WIN32)
-    set(CPACK_SOURCE_IGNORE_FILES
-    "/lib/"
-    "\\\\.dll$"
-    "${CPACK_SOURCE_IGNORE_FILES}")
-endif()
-
-set(CPACK_SOURCE_PACKAGE_FILE_NAME
-    "${CMAKE_PROJECT_NAME}-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
-
-if(WIN32)
-    set(CPACK_GENERATOR "NSIS")
-    set(CPACK_SOURCE_GENERATOR "ZIP")
-    set(CPACK_NSIS_PACKAGE_NAME "OpenCV ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}rc")
-    set(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}\\\\doc\\\\opencv.ico")
-    set(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}\\\\doc\\\\opencv.ico")
-    #set(CPACK_PACKAGE_ICON "utils/opencv.ico") 
-        
-    set(CPACK_NSIS_INSTALLED_ICON_NAME "${CMAKE_SOURCE_DIR}\\\\doc\\\\opencv.ico")
-    set(CPACK_NSIS_HELP_LINK "http:\\\\\\\\opencv.willowgarage.com")
-    set(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\opencv.willowgarage.com")
-    set(CPACK_NSIS_CONTACT "")
-    set(CPACK_NSIS_DISPLAY_NAME "Open Source Computer Vision Library")
-
-    set(CPACK_NSIS_MENU_LINKS
-        "http://opencv.willowgarage.com" "Start Page"
-        "doc\\\\opencv2refman.pdf" "The OpenCV Reference Manual"
-        "doc\\\\opencv_tutorials.pdf" "The OpenCV Tutorials for Beginners"
-        "CMakeLists.txt" "The Build Script (open with CMake)"
-        "samples\\\\c" "C Samples"
-        "samples\\\\cpp" "C++ Samples"
-        "samples\\\\python" "Python Samples")
-    
-    # Add "<install_path>/bin" to the system PATH
-    set(CPACK_NSIS_MODIFY_PATH ON)
-else()
-    set(CPACK_GENERATOR "TBZ2")
-    set(CPACK_SOURCE_GENERATOR "TBZ2")
-    
-    if(APPLE)
-    set(CPACK_GENERATOR "PackageMaker;TBZ2")
-    endif()
-endif()
-
-include(CPack)
diff --git a/android/CMakeCache.android.initial.cmake b/android/CMakeCache.android.initial.cmake
index e6b86d3484..b934915056 100644
--- a/android/CMakeCache.android.initial.cmake
+++ b/android/CMakeCache.android.initial.cmake
@@ -3,20 +3,6 @@
 # run cmake with:
 # cmake -C 
 ########################
-#Build all examples
-set(BUILD_EXAMPLES OFF CACHE BOOL "" )
-
-#Build Reference Manual
-set(BUILD_REFMAN OFF CACHE BOOL "" )
-
-#Build LaTeX OpenCV Documentation
-#set(BUILD_LATEX_DOCS OFF CACHE BOOL "" )
-
-#Build with Python support
-set(BUILD_NEW_PYTHON_SUPPORT OFF CACHE BOOL "" )
-
-#Build a installer with the SDK
-set(BUILD_PACKAGE OFF CACHE BOOL "" )
 
 #Build shared libraries (.dll/.so CACHE BOOL "" ) instead of static ones (.lib/.a CACHE BOOL "" )
 set(BUILD_SHARED_LIBS OFF CACHE BOOL "" )
@@ -24,8 +10,7 @@ set(BUILD_SHARED_LIBS OFF CACHE BOOL "" )
 #Build 3rd party libraries
 set(OPENCV_BUILD_3RDPARTY_LIBS ON CACHE BOOL "" )
 
-#Choose the type of build, options are: None Debug Release RelWithDebInfo
-# MinSizeRel.
+#Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel.
 set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" )
 
 #Include IEEE1394 support
@@ -88,6 +73,9 @@ set(WITH_V4L OFF CACHE BOOL "" )
 #Include Xine support (GPL CACHE BOOL "" )
 set(WITH_XINE OFF CACHE BOOL "" )
 
+#no python available on Android
+set(BUILD_NEW_PYTHON_SUPPORT OFF CACHE INTERNAL "" FORCE)
+
 #Enable SSE instructions
 SET( ENABLE_SSE OFF CACHE INTERNAL "" FORCE )
 
@@ -106,5 +94,5 @@ SET( ENABLE_SSE42 OFF CACHE INTERNAL "" FORCE )
 #Enable SSSE3 instructions
 SET( ENABLE_SSSE3 OFF CACHE INTERNAL "" FORCE )
 
-#Set output folder to "libs" instead of "lib" for better compatibility with java projects
-SET( LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/libs CACHE PATH "path for android libs" )
+#Set output folder to ${CMAKE_BINARY_DIR}
+set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_BINARY_DIR} CACHE PATH "root for library output, set this to change where android libs are compiled to" )
diff --git a/android/README.android b/android/README.android
index 401a10a143..b9c688096d 100644
--- a/android/README.android
+++ b/android/README.android
@@ -1 +1 @@
-See http://opencv.willowgarage.com/wiki/Android2.3
+See http://opencv.willowgarage.com/wiki/Android
diff --git a/android/android-opencv/AndroidManifest.xml b/android/android-opencv/AndroidManifest.xml
deleted file mode 100644
index 8d3efb0fd7..0000000000
--- a/android/android-opencv/AndroidManifest.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.opencv" android:versionCode="1" android:versionName="0.1">
-
-	<application android:debuggable="true">
-		<!-- The activity tag here is currently not used. The main project TicTacToeMain 
-			must currently redefine the activities to be used from the libraries. However 
-			later the tools will pick up the activities from here and merge them automatically, 
-			so it's best to define your activities here like for any regular Android 
-			project. -->
-		<activity android:name="com.opencv.OpenCV">
-			<intent-filter>
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-		</activity>
-		<activity android:name="com.opencv.calibration.ChessBoardChooser" />
-		<activity android:name="com.opencv.calibration.CameraConfig" />
-		<activity android:name="com.opencv.calibration.CalibrationViewer" />
-		<service android:name="com.opencv.calibration.services.CalibrationService" />
-	</application>
-	<uses-sdk android:minSdkVersion="7" />
-
-	<!-- set the opengl version -->
-	<uses-feature android:glEsVersion="0x00020000" />
-	<!-- set the opengl version -->
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-
-</manifest> 
diff --git a/android/android-opencv/AndroidOpenCVConfig.cmake.in b/android/android-opencv/AndroidOpenCVConfig.cmake.in
deleted file mode 100644
index 53cdfc2cc3..0000000000
--- a/android/android-opencv/AndroidOpenCVConfig.cmake.in
+++ /dev/null
@@ -1,44 +0,0 @@
-# ============================================================================
-#  The AndroidOpenCV CMake configuration file
-#
-#             ** File generated automatically, do not modify **
-#
-#  Usage from an external project:
-#    In your CMakeLists.txt, add these lines:
-#
-#    FIND_PACKAGE(AndroidOpenCV REQUIRED )
-#    TARGET_LINK_LIBRARIES(MY_TARGET_NAME ${AndroidOpenCV_LIBS})
-#
-#    This file will define the following variables:
-#      - AndroidOpenCV_LIBS      : The list of libraries to links against.
-#      - AndroidOpenCV_LIB_DIR   : The directory where lib files are. 
-#                                  Calling LINK_DIRECTORIES with this path
-#                                  is NOT needed.
-#      - AndroidOpenCV_INCLUDE_DIRS   : The AndroidOpenCV include directories.
-#      - AndroidOpenCV_SWIG_DIR : The swig path
-#
-# ===========================================================================
-
-
-# ======================================================
-# Include directories to add to the user project:
-# ======================================================
-
-# Provide the include directories to the caller
-SET(AndroidOpenCV_INCLUDE_DIRS @CMAKE_INCLUDE_DIRS_CONFIGCMAKE@)
-INCLUDE_DIRECTORIES(${AndroidOpenCV_INCLUDE_DIRS})
-
-# ======================================================
-# Link directories to add to the user project:
-# ======================================================
-
-# Provide the libs directory anyway, it may be needed in some cases.
-SET(AndroidOpenCV_LIB_DIR @CMAKE_LIB_DIRS_CONFIGCMAKE@)
-LINK_DIRECTORIES(${AndroidOpenCV_LIB_DIR})
-
-# ======================================================
-# Libraries to add to the user project:
-# ======================================================
-SET(AndroidOpenCV_LIBS @CMAKE_LIBS_CONFIGCMAKE@)
-
-SET(AndroidOpenCV_SWIG_DIR @CMAKE_SWIG_DIR_CONFIGCMAKE@)
diff --git a/android/android-opencv/CMakeLists.txt b/android/android-opencv/CMakeLists.txt
deleted file mode 100644
index 27377666e2..0000000000
--- a/android/android-opencv/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-
-project(android-jni)
-
-add_subdirectory(jni)
diff --git a/android/android-opencv/README.txt b/android/android-opencv/README.txt
deleted file mode 100644
index 8082add891..0000000000
--- a/android/android-opencv/README.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-=========================================
-CMake Build
-=========================================
-#path to the android build of opencv
-opencv_dir=`pwd`/../build
-mkdir build
-cd build
-cmake -DOpenCV_DIR=$opencv_dir -DCMAKE_TOOLCHAIN_FILE=$ANDTOOLCHAIN ..
-
-=========================================
-Android Build
-=========================================
-sh project_create.sh
-ant compile
-
diff --git a/android/android-opencv/cmake_android.cmd b/android/android-opencv/cmake_android.cmd
deleted file mode 100644
index fdb8e45969..0000000000
--- a/android/android-opencv/cmake_android.cmd
+++ /dev/null
@@ -1,7 +0,0 @@
-@ECHO OFF
-SETLOCAL
-PUSHD %~dp0
-SET PROJECT_NAME=android-opencv
-CALL ..\scripts\build.cmd %*
-POPD
-ENDLOCAL
\ No newline at end of file
diff --git a/android/android-opencv/cmake_android.sh b/android/android-opencv/cmake_android.sh
deleted file mode 100644
index 3e90e33076..0000000000
--- a/android/android-opencv/cmake_android.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-cd `dirname $0`
-
-opencv_build_dir=`pwd`/../build
-mkdir -p build
-cd build
-
-cmake -DOpenCVDIR=$opencv_build_dir -DCMAKE_TOOLCHAIN_FILE=../../android.toolchain.cmake ..
-
diff --git a/android/android-opencv/cmake_android_neon.sh b/android/android-opencv/cmake_android_neon.sh
deleted file mode 100644
index 56c14923c6..0000000000
--- a/android/android-opencv/cmake_android_neon.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-cd `dirname $0`
-
-opencv_build_dir=`pwd`/../build_neon
-mkdir -p build_neon
-cd build_neon
-
-cmake -DOpenCVDIR=$opencv_build_dir -DARM_TARGET="armeabi-v7a with NEON" -DCMAKE_TOOLCHAIN_FILE=../../android.toolchain.cmake ..
diff --git a/android/android-opencv/jni/CMakeLists.txt b/android/android-opencv/jni/CMakeLists.txt
deleted file mode 100644
index 1f26f0de1a..0000000000
--- a/android/android-opencv/jni/CMakeLists.txt
+++ /dev/null
@@ -1,70 +0,0 @@
-#########################################################
-# Find opencv and android-opencv
-#########################################################
-
-set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../build 
-    CACHE PATH "The path where you built opencv for android")
-find_package(OpenCV REQUIRED)
-
-#########################################################
-#c flags, included, and lib dependencies
-#########################################################
-#notice the "recycling" of CMAKE_C_FLAGS
-#this is necessary to pick up android flags
-set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR} 
-                    ${CMAKE_CURRENT_SOURCE_DIR}/include)
-
-set( LIBRARY_DEPS ${OpenCV_LIBS} )
-if(ANDROID)
-  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl GLESv2)
-endif(ANDROID)
-
-#########################################################
-#SWIG STUFF
-#########################################################
-#the java package to place swig generated java files in
-set(MY_PACKAGE com.opencv.jni)
-
-if(NOT ANDROID)
-  #non android swig and jni
-  #jni is available by default on android
-  find_package(JNI REQUIRED)
-  include_directories(${JNI_INCLUDE_DIRS})
-  FIND_PACKAGE(SWIG)
-endif()
-
-INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
-
-if(ANDROID)
-  #this will set the output path for the java package
-  #and properly create the package declarations in generated java sources
-  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
-endif(ANDROID)
-
-SET_SOURCE_FILES_PROPERTIES(android-cv.i PROPERTIES CPLUSPLUS ON)
-
-SWIG_ADD_MODULE(android-opencv java 
-  android-cv.i
-  Calibration.cpp
-  gl_code.cpp
-  image_pool.cpp
-  yuv420sp2rgb.c
-  #yuv420rgb888c.c
-  #yuv420rgb888.s
-  yuv2rgb16tab.c
-  )
-  
-target_link_libraries(android-opencv ${LIBRARY_DEPS} )
-
-###################################################################
-# Setup the configure file for other's to link against.
-###################################################################
-set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE ${CMAKE_CURRENT_SOURCE_DIR}/include)
-set(CMAKE_LIB_DIRS_CONFIGCMAKE ${LIBRARY_OUTPUT_PATH})
-set(CMAKE_LIBS_CONFIGCMAKE android-opencv)
-set(CMAKE_SWIG_DIR_CONFIGCMAKE ${CMAKE_CURRENT_SOURCE_DIR})
-configure_file( "${CMAKE_SOURCE_DIR}/AndroidOpenCVConfig.cmake.in"
-                "${CMAKE_BINARY_DIR}/AndroidOpenCVConfig.cmake"
-                IMMEDIATE @ONLY)
diff --git a/android/android-opencv/jni/Calibration.cpp b/android/android-opencv/jni/Calibration.cpp
deleted file mode 100644
index 9ba8fa8ac0..0000000000
--- a/android/android-opencv/jni/Calibration.cpp
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * Processor.cpp
- *
- *  Created on: Jun 13, 2010
- *      Author: ethan
- */
-
-#include "Calibration.h"
-
-#include <sys/stat.h>
-
-using namespace cv;
-
-Calibration::Calibration() :
-  patternsize(6, 8)
-{
-
-}
-
-Calibration::~Calibration()
-{
-
-}
-
-namespace
-{
-double computeReprojectionErrors(const vector<vector<Point3f> >& objectPoints,
-                                 const vector<vector<Point2f> >& imagePoints, const vector<Mat>& rvecs, const vector<
-                                     Mat>& tvecs, const Mat& cameraMatrix, const Mat& distCoeffs,
-                                 vector<float>& perViewErrors)
-{
-  vector<Point2f> imagePoints2;
-  int i, totalPoints = 0;
-  double totalErr = 0, err;
-  perViewErrors.resize(objectPoints.size());
-
-  for (i = 0; i < (int)objectPoints.size(); i++)
-  {
-    projectPoints(Mat(objectPoints[i]), rvecs[i], tvecs[i], cameraMatrix, distCoeffs, imagePoints2);
-    err = norm(Mat(imagePoints[i]), Mat(imagePoints2), CV_L1);
-    int n = (int)objectPoints[i].size();
-    perViewErrors[i] = err / n;
-    totalErr += err;
-    totalPoints += n;
-  }
-
-  return totalErr / totalPoints;
-}
-
-void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners)
-{
-  corners.resize(0);
-
-  for (int i = 0; i < boardSize.height; i++)
-    for (int j = 0; j < boardSize.width; j++)
-      corners.push_back(Point3f(float(j * squareSize), float(i * squareSize), 0));
-}
-
-/**from opencv/samples/cpp/calibration.cpp
- *
- */
-bool runCalibration(vector<vector<Point2f> > imagePoints, Size imageSize, Size boardSize, float squareSize,
-                    float aspectRatio, int flags, Mat& cameraMatrix, Mat& distCoeffs, vector<Mat>& rvecs,
-                    vector<Mat>& tvecs, vector<float>& reprojErrs, double& totalAvgErr)
-{
-  cameraMatrix = Mat::eye(3, 3, CV_64F);
-  if (flags & CV_CALIB_FIX_ASPECT_RATIO)
-    cameraMatrix.at<double> (0, 0) = aspectRatio;
-
-  distCoeffs = Mat::zeros(4, 1, CV_64F);
-
-  vector<vector<Point3f> > objectPoints(1);
-  calcChessboardCorners(boardSize, squareSize, objectPoints[0]);
-  for (size_t i = 1; i < imagePoints.size(); i++)
-    objectPoints.push_back(objectPoints[0]);
-
-  calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags);
-
-  bool ok = checkRange(cameraMatrix, CV_CHECK_QUIET) && checkRange(distCoeffs, CV_CHECK_QUIET);
-
-  totalAvgErr
-      = computeReprojectionErrors(objectPoints, imagePoints, rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
-
-  return ok;
-}
-void saveCameraParams(const string& filename, Size imageSize, Size boardSize, float squareSize, float aspectRatio,
-                      int flags, const Mat& cameraMatrix, const Mat& distCoeffs, const vector<Mat>& rvecs,
-                      const vector<Mat>& tvecs, const vector<float>& reprojErrs,
-                      const vector<vector<Point2f> >& imagePoints, double totalAvgErr)
-{
-  FileStorage fs(filename, FileStorage::WRITE);
-
-  time_t t;
-  time(&t);
-  struct tm *t2 = localtime(&t);
-  char buf[1024];
-  strftime(buf, sizeof(buf) - 1, "%c", t2);
-
-  fs << "calibration_time" << buf;
-
-  if (!rvecs.empty() || !reprojErrs.empty())
-    fs << "nframes" << (int)std::max(rvecs.size(), reprojErrs.size());
-  fs << "image_width" << imageSize.width;
-  fs << "image_height" << imageSize.height;
-  fs << "board_width" << boardSize.width;
-  fs << "board_height" << boardSize.height;
-  fs << "squareSize" << squareSize;
-
-  if (flags & CV_CALIB_FIX_ASPECT_RATIO)
-    fs << "aspectRatio" << aspectRatio;
-
-  if (flags != 0)
-  {
-    sprintf(buf, "flags: %s%s%s%s", flags & CV_CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "", flags
-        & CV_CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "", flags & CV_CALIB_FIX_PRINCIPAL_POINT
-        ? "+fix_principal_point" : "", flags & CV_CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "");
-    cvWriteComment(*fs, buf, 0);
-  }
-
-  fs << "flags" << flags;
-
-  fs << "camera_matrix" << cameraMatrix;
-  fs << "distortion_coefficients" << distCoeffs;
-
-  fs << "avg_reprojection_error" << totalAvgErr;
-  if (!reprojErrs.empty())
-    fs << "per_view_reprojection_errors" << Mat(reprojErrs);
-
-  if (!rvecs.empty() && !tvecs.empty())
-  {
-    Mat bigmat(rvecs.size(), 6, CV_32F);
-    for (size_t i = 0; i < rvecs.size(); i++)
-    {
-      Mat r = bigmat(Range(i, i + 1), Range(0, 3));
-      Mat t = bigmat(Range(i, i + 1), Range(3, 6));
-      rvecs[i].copyTo(r);
-      tvecs[i].copyTo(t);
-    }
-    cvWriteComment(*fs, "a set of 6-tuples (rotation vector + translation vector) for each view", 0);
-    fs << "extrinsic_parameters" << bigmat;
-  }
-
-  if (!imagePoints.empty())
-  {
-    Mat imagePtMat(imagePoints.size(), imagePoints[0].size(), CV_32FC2);
-    for (size_t i = 0; i < imagePoints.size(); i++)
-    {
-      Mat r = imagePtMat.row(i).reshape(2, imagePtMat.cols);
-      Mat(imagePoints[i]).copyTo(r);
-    }
-    fs << "image_points" << imagePtMat;
-  }
-}
-}//anon namespace
-bool Calibration::detectAndDrawChessboard(int idx, image_pool* pool)
-{
-
-  bool patternfound = false;
-  Mat grey = pool->getGrey(idx);
-  if (grey.empty())
-    return false;
-  vector<Point2f> corners;
-
-  patternfound = findChessboardCorners(grey, patternsize, corners,CALIB_CB_FILTER_QUADS + CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE
-                                                + CALIB_CB_FAST_CHECK);
-  Mat img = pool->getImage(idx);
-
-  if (corners.size() < 1)
-    return false;
-
-  if (patternfound)
-  {
-    cornerSubPix(grey, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
-    imagepoints.push_back(corners);
-  }
-
-  drawChessboardCorners(img, patternsize, Mat(corners), patternfound);
-
-  imgsize = grey.size();
-
-  return patternfound;
-
-}
-
-void Calibration::drawText(int i, image_pool* pool, const char* ctext)
-{
-  // Use "y" to show that the baseLine is about
-  string text = ctext;
-  int fontFace = FONT_HERSHEY_COMPLEX_SMALL;
-  double fontScale = .8;
-  int thickness = .5;
-
-  Mat img = pool->getImage(i);
-
-  int baseline = 0;
-  Size textSize = getTextSize(text, fontFace, fontScale, thickness, &baseline);
-  baseline += thickness;
-
-  // center the text
-  Point textOrg((img.cols - textSize.width) / 2, (img.rows - textSize.height * 2));
-
-  // draw the box
-  rectangle(img, textOrg + Point(0, baseline), textOrg + Point(textSize.width, -textSize.height), Scalar(0, 0, 255),
-            CV_FILLED);
-  // ... and the baseline first
-  line(img, textOrg + Point(0, thickness), textOrg + Point(textSize.width, thickness), Scalar(0, 0, 255));
-
-  // then put the text itself
-  putText(img, text, textOrg, fontFace, fontScale, Scalar::all(255), thickness, 8);
-}
-
-void Calibration::resetChess()
-{
-
-  imagepoints.clear();
-}
-
-void Calibration::calibrate(const char* filename)
-{
-
-  vector<Mat> rvecs, tvecs;
-  vector<float> reprojErrs;
-  double totalAvgErr = 0;
-  int flags = 0;
-  flags |= CV_CALIB_FIX_PRINCIPAL_POINT | CV_CALIB_FIX_ASPECT_RATIO;
-  bool writeExtrinsics = true;
-  bool writePoints = true;
-
-  bool ok = runCalibration(imagepoints, imgsize, patternsize, 1.f, 1.f, flags, K, distortion, rvecs, tvecs, reprojErrs,
-                           totalAvgErr);
-
-  if (ok)
-  {
-
-    saveCameraParams(filename, imgsize, patternsize, 1.f, 1.f, flags, K, distortion, writeExtrinsics ? rvecs : vector<
-        Mat> (), writeExtrinsics ? tvecs : vector<Mat> (), writeExtrinsics ? reprojErrs : vector<float> (), writePoints
-        ? imagepoints : vector<vector<Point2f> > (), totalAvgErr);
-  }
-
-}
-
-int Calibration::getNumberDetectedChessboards()
-{
-  return imagepoints.size();
-}
diff --git a/android/android-opencv/jni/Calibration.i b/android/android-opencv/jni/Calibration.i
deleted file mode 100644
index ba6154b3c7..0000000000
--- a/android/android-opencv/jni/Calibration.i
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * include the headers required by the generated cpp code
- */
-%{
-#include "Calibration.h"
-#include "image_pool.h"
-using namespace cv;
-%}
-
-
-class Calibration {
-public:
-
-	Size patternsize;
-	
-	Calibration();
-	virtual ~Calibration();
-
-	bool detectAndDrawChessboard(int idx, image_pool* pool);
-	
-	void resetChess();
-	
-	int getNumberDetectedChessboards();
-	
-	void calibrate(const char* filename);
-	
-	void drawText(int idx, image_pool* pool, const char* text);
-};
diff --git a/android/android-opencv/jni/android-cv-typemaps.i b/android/android-opencv/jni/android-cv-typemaps.i
deleted file mode 100644
index cae2d6b63b..0000000000
--- a/android/android-opencv/jni/android-cv-typemaps.i
+++ /dev/null
@@ -1,6 +0,0 @@
-%feature("director") Mat;
-%feature("director") glcamera;
-%feature("director") image_pool;
-%typemap("javapackage") Mat, Mat *, Mat & "com.opencv.jni";
-%typemap("javapackage") glcamera, glcamera *, glcamera & "com.opencv.jni";
-%typemap("javapackage") image_pool, image_pool *, image_pool & "com.opencv.jni";
\ No newline at end of file
diff --git a/android/android-opencv/jni/android-cv.i b/android/android-opencv/jni/android-cv.i
deleted file mode 100644
index f6661aa698..0000000000
--- a/android/android-opencv/jni/android-cv.i
+++ /dev/null
@@ -1,58 +0,0 @@
-/* File : android-cv.i
-
-import this file, and make sure to add the System.loadlibrary("android-opencv")
-before loading any lib that depends on this.
- */
-
-%module opencv
-%{
-#include "image_pool.h"
-#include "glcamera.h"
-using namespace cv;
-%}
-#ifndef SWIGIMPORTED
-%include "various.i"
-%include "typemaps.i"
-%include "arrays_java.i"
-#endif
-
-/**
- * Make all the swig pointers public, so that
- * external libraries can refer to these, otherwise they default to 
- * protected...
- */
-%typemap(javabody) SWIGTYPE %{
-  private long swigCPtr;
-  protected boolean swigCMemOwn;
-  public $javaclassname(long cPtr, boolean cMemoryOwn) {
-	swigCMemOwn = cMemoryOwn;
-	swigCPtr = cPtr;
-  }
-  public static long getCPtr($javaclassname obj) {
-	return (obj == null) ? 0 : obj.swigCPtr;
-  }
-%}
-
-
-%pragma(java) jniclasscode=%{
-  static {
-    try {
-    	//load the library, make sure that libandroid-opencv.so is in your <project>/libs/armeabi directory
-    	//so that android sdk automatically installs it along with the app.
-        System.loadLibrary("android-opencv");
-    } catch (UnsatisfiedLinkError e) {
-    	//badness
-    	throw e;
-     
-    }
-  }
-%}
-
-
-%include "cv.i"
-
-%include "glcamera.i"
-
-%include "image_pool.i"
-
-%include "Calibration.i"
diff --git a/android/android-opencv/jni/buffers.i b/android/android-opencv/jni/buffers.i
deleted file mode 100644
index 42cca9cecf..0000000000
--- a/android/android-opencv/jni/buffers.i
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * These typemaps provide support for sharing data between JNI and JVM code
- * using NIO direct buffers. It is the responsibility of the JVM code to
- * allocate a direct buffer of the appropriate size.
- *
- * Example use:
-
- * Wrapping:
- * %include "buffers.i" 
- * %apply int* BUFF {int* buffer}
- * int read_foo_int(int* buffer);
- *
- * Java:
- * IntBuffer buffer = IntBuffer.allocateDirect(nInts*4).order(ByteOrder.nativeOrder()).asIntBuffer();
- * Example.read_foo_int(buffer);
- *
-
- * The following typemaps are defined:
- * void* BUFF           <--> javax.nio.Buffer
- * char* BUFF           <--> javax.nio.ByteBuffer
- * char* CBUFF          <--> javax.nio.CharBuffer
- * unsigned char* INBUFF/OUTBUFF  <--> javax.nio.ShortBuffer
- * short* BUFF          <--> javax.nio.ShortBuffer 
- * unsigned short* INBUFF/OUTBUFF <--> javax.nio.IntBuffer
- * int* BUFF            <--> javax.nio.IntBuffer
- * unsigned int* INBUFF/OUTBUFF   <--> javax.nio.LongBuffer
- * long* BUFF           <--> javax.nio.IntBuffer
- * unsigned long* INBUFF/OUTBUF  <--> javax.nio.LongBuffer
- * long long* BUFF      <--> javax.nio.LongBuffer
- * float* BUFF          <--> javax.nio.FloatBuffer
- * double* BUFF         <--> javax.nio.DoubleBuffer
- *
- * Note the potential for data loss in the conversion from 
- * the C type 'unsigned long' to the signed Java long type.
- * Hopefully, I can implement a workaround with BigNumber in the future.
- *
- * The use of ByteBuffer vs CharBuffer for the char* type should
- * depend on the type of data. In general you'll probably
- * want to use CharBuffer for actual text data.
- */
-/*
- * This macro is used to define the nio buffers for primitive types.
- */
-%define NIO_BUFFER_TYPEMAP(CTYPE, LABEL, BUFFERTYPE)
-%typemap(jni) CTYPE* LABEL "jobject"
-%typemap(jtype) CTYPE* LABEL "BUFFERTYPE"
-%typemap(jstype) CTYPE* LABEL "BUFFERTYPE"
-%typemap(javain, 
-	pre="    assert $javainput.isDirect() : \"Buffer must be allocated direct.\";") CTYPE* LABEL "$javainput"
-%typemap(javaout) CTYPE* LABEL {
-    return $jnicall;
-}
-%typemap(in) CTYPE* LABEL {
-  $1 = (CTYPE*)(jenv)->GetDirectBufferAddress( $input);
-  if ($1 == NULL) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
-  }
-}
-%typemap(memberin) CTYPE* LABEL {
-  if ($input) {
-    $1 = $input;
-  } else {
-    $1 = 0;
-  }
-}
-%typemap(freearg) CTYPE* LABEL ""
-%enddef
-
-NIO_BUFFER_TYPEMAP(void, BUFF, java.nio.Buffer);
-NIO_BUFFER_TYPEMAP(char, BUFF, java.nio.ByteBuffer);
-NIO_BUFFER_TYPEMAP(char, CBUFF, java.nio.CharBuffer);
-/*NIO_BUFFER_TYPEMAP(unsigned char, BUFF, java.nio.ShortBuffer);*/
-NIO_BUFFER_TYPEMAP(short, BUFF, java.nio.ShortBuffer);
-NIO_BUFFER_TYPEMAP(unsigned short, BUFF, java.nio.IntBuffer);
-NIO_BUFFER_TYPEMAP(int, BUFF, java.nio.IntBuffer);
-NIO_BUFFER_TYPEMAP(unsigned int, BUFF, java.nio.LongBuffer);
-NIO_BUFFER_TYPEMAP(long, BUFF, java.nio.IntBuffer);
-NIO_BUFFER_TYPEMAP(unsigned long, BUFF, java.nio.LongBuffer);
-NIO_BUFFER_TYPEMAP(long long, BUFF, java.nio.LongBuffer);
-NIO_BUFFER_TYPEMAP(float, BUFF, java.nio.FloatBuffer);
-NIO_BUFFER_TYPEMAP(double, BUFF, java.nio.DoubleBuffer);
-#undef NIO_BUFFER_TYPEMAP
-
-
-%define UNSIGNED_NIO_BUFFER_TYPEMAP(CTYPE, BSIZE, BUFFERTYPE, PACKFCN, UNPACKFCN)
-%typemap(jni) CTYPE* INBUFF "jobject"
-%typemap(jtype) CTYPE* INBUFF "java.nio.ByteBuffer"
-%typemap(jstype) CTYPE* INBUFF "BUFFERTYPE"
-%typemap(javain, 
-	pre="    java.nio.ByteBuffer tmp$javainput = PACKFCN($javainput, true);") CTYPE* INBUFF "tmp$javainput"
-%typemap(javaout) CTYPE* INBUFF {
-    return $jnicall;
-}
-%typemap(in) CTYPE* INBUFF {
-  $1 = (jenv)->GetDirectBufferAddress($input);
-  if ($1 == NULL) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
-  }
-}
-%typemap(memberin) CTYPE* INBUFF {
-  if ($input) {
-    $1 = $input;
-  } else {
-    $1 = 0;
-  }
-}
-%typemap(freearg) CTYPE* INBUFF ""
-
-%typemap(jni) CTYPE* OUTBUFF "jobject"
-%typemap(jtype) CTYPE* OUTBUFF "java.nio.ByteBuffer"
-%typemap(jstype) CTYPE* OUTBUFF "BUFFERTYPE"
-%typemap(javain, 
-	pre="    java.nio.ByteBuffer tmp$javainput = java.nio.ByteBuffer.allocateDirect($javainput.capacity()*BSIZE).order($javainput.order());",
-        post="       UNPACKFCN(tmp$javainput, $javainput);") CTYPE* OUTBUFF "tmp$javainput"
-%typemap(javaout) CTYPE* OUTBUFF {
-    return $jnicall;
-}
-%typemap(in) CTYPE* OUTBUFF {
-  $1 = (jenv)->GetDirectBufferAddress( $input);
-  if ($1 == NULL) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
-  }
-}
-%typemap(memberin) CTYPE* OUTBUFF {
-  if ($input) {
-    $1 = $input;
-  } else {
-    $1 = 0;
-  }
-}
-%typemap(freearg) CTYPE* OUTBUFF ""
-%enddef
-
-UNSIGNED_NIO_BUFFER_TYPEMAP(unsigned char, 1, java.nio.ShortBuffer, permafrost.hdf.libhdf.BufferUtils.packUChar, permafrost.hdf.libhdf.BufferUtils.unpackUChar);
-UNSIGNED_NIO_BUFFER_TYPEMAP(unsigned short, 2, java.nio.IntBuffer, permafrost.hdf.libhdf.BufferUtils.packUShort, permafrost.hdf.libhdf.BufferUtils.unpackUShort);
-UNSIGNED_NIO_BUFFER_TYPEMAP(unsigned int, 4, java.nio.LongBuffer, permafrost.hdf.libhdf.BufferUtils.packUInt, permafrost.hdf.libhdf.BufferUtils.unpackUInt);
-UNSIGNED_NIO_BUFFER_TYPEMAP(unsigned long, 4, java.nio.LongBuffer, permafrost.hdf.libhdf.BufferUtils.packUInt, permafrost.hdf.libhdf.BufferUtils.unpackUInt);
-
-/*
-%typemap(jni) unsigned char* BUFF "jobject"
-%typemap(jtype) unsigned char* BUFF "java.nio.ByteBuffer"
-%typemap(jstype) unsigned char* BUFF "java.nio.ShortBuffer"
-%typemap(javain, 
-	pre="    java.nio.ByteBuffer tmp$javainput = permafrost.hdf.libhdf.BufferUtils.packUChar($javainput, true);",
-        post="      permafrost.hdf.libhdf.BufferUtils.unpackUChar(tmp$javainput, $javainput);") unsigned char* BUFF "tmp$javainput"
-%typemap(javaout) unsigned char* BUFF {
-    return $jnicall;
-}
-%typemap(in) unsigned char* BUFF {
-  $1 = (const char*)(jenv)->GetDirectBufferAddress( $input);
-  if ($1 == NULL) {
-    SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unable to get address of direct buffer. Buffer must be allocated direct.");
-  }
-}
-%typemap(memberin) unsigned char* BUFF {
-  if ($input) {
-    $1 = $input;
-  } else {
-    $1 = 0;
-  }
-}
-%typemap(freearg) unsigned char* BUFF ""
-*/
-
-#undef UNSIGNED_NIO_BUFFER_TYPEMAP
\ No newline at end of file
diff --git a/android/android-opencv/jni/cv.i b/android/android-opencv/jni/cv.i
deleted file mode 100644
index 167d55d137..0000000000
--- a/android/android-opencv/jni/cv.i
+++ /dev/null
@@ -1,156 +0,0 @@
-%typemap(javaimports) Mat "
-/** Wrapper for the OpenCV Mat object. Good for passing around as a pointer to a Mat.
-*/"
-
-%typemap(javaimports) Size "
-/** Wrapper for the OpenCV Size object. Good for setting dimensions of cv::Mat...
-*/"
-
-
-class Size{
-public:
-	Size();
-	Size(int width,int height);
-	~Size();
-	int width;
-	int height;	
-};
-
-#define CV_CN_MAX     512
-#define CV_CN_SHIFT   3
-#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)
-
-#define CV_8U   0
-#define CV_8S   1
-#define CV_16U  2
-#define CV_16S  3
-#define CV_32S  4
-#define CV_32F  5
-#define CV_64F  6
-#define CV_USRTYPE1 7
-
-#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
-#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)
-
-#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
-#define CV_MAKE_TYPE CV_MAKETYPE
-
-#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
-#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
-#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
-#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
-#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))
-
-#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
-#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
-#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
-#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
-#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))
-
-#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
-#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
-#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
-#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
-#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))
-
-#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
-#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
-#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
-#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
-#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))
-
-#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
-#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
-#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
-#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
-#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))
-
-#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
-#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
-#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
-#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
-#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))
-
-#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
-#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
-#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
-#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
-#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))
-
-#define CV_AUTO_STEP  0x7fffffff
-#define CV_WHOLE_ARR  cvSlice( 0, 0x3fffffff )
-
-#define CV_MAT_CN_MASK          ((CV_CN_MAX - 1) << CV_CN_SHIFT)
-#define CV_MAT_CN(flags)        ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
-#define CV_MAT_TYPE_MASK        (CV_DEPTH_MAX*CV_CN_MAX - 1)
-#define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)
-#define CV_MAT_CONT_FLAG_SHIFT  14
-#define CV_MAT_CONT_FLAG        (1 << CV_MAT_CONT_FLAG_SHIFT)
-#define CV_IS_MAT_CONT(flags)   ((flags) & CV_MAT_CONT_FLAG)
-#define CV_IS_CONT_MAT          CV_IS_MAT_CONT
-#define CV_SUBMAT_FLAG_SHIFT    15
-#define CV_SUBMAT_FLAG          (1 << CV_SUBMAT_FLAG_SHIFT)
-#define CV_IS_SUBMAT(flags)     ((flags) & CV_MAT_SUBMAT_FLAG)
-
-#define CV_MAGIC_MASK       0xFFFF0000
-#define CV_MAT_MAGIC_VAL    0x42420000
-#define CV_TYPE_NAME_MAT    "opencv-matrix"
-
-class Mat {
-public:
-	Mat();
-	~Mat();
-	void create(Size size, int type);
-	int channels() const;
- %immutable;
-	int rows;
-	int cols;
-};
-
-template<class _Tp> class Ptr
-{
-public:
-    //! empty constructor
-    Ptr();
-    //! take ownership of the pointer. The associated reference counter is allocated and set to 1
-    Ptr(_Tp* _obj);
-    //! calls release()
-    ~Ptr();
-    //! copy constructor. Copies the members and calls addref()
-    Ptr(const Ptr& ptr);
-    //! copy operator. Calls ptr.addref() and release() before copying the members
-   // Ptr& operator = (const Ptr& ptr);
-    //! increments the reference counter
-    void addref();
-    //! decrements the reference counter. If it reaches 0, delete_obj() is called
-    void release();
-    //! deletes the object. Override if needed
-    void delete_obj();
-    //! returns true iff obj==NULL
-    bool empty() const;
-
-    
-    //! helper operators making "Ptr<T> ptr" use very similar to "T* ptr".
-    _Tp* operator -> ();
-   // const _Tp* operator -> () const;
-
-   // operator _Tp* ();
-  //  operator const _Tp*() const;
-    
-protected:
-    _Tp* obj; //< the object pointer.
-    int* refcount; //< the associated reference counter
-};
-
-
-
-%template(PtrMat) Ptr<Mat>;
-
-void imwrite(const char* image_name, const Mat& image);
-Mat imread(const char* image_name);
-
- %include "buffers.i" 
- %apply char* BUFF {const char* buffer}
- %apply char* BUFF {char* buffer}
-void copyMatToBuffer(char* buffer, const Mat& mat);
-void copyBufferToMat(Mat& mat, const char* buffer);
\ No newline at end of file
diff --git a/android/android-opencv/jni/gl_code.cpp b/android/android-opencv/jni/gl_code.cpp
deleted file mode 100644
index 358b4483cb..0000000000
--- a/android/android-opencv/jni/gl_code.cpp
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// OpenGL ES 2.0 code
-
-#include <jni.h>
-#if __ANDROID__
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#else
-#include <GL/gl.h>
-#endif
-
-#include "android_logger.h"
-
-#include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdint.h>
-
-#include "glcamera.h"
-#include "image_pool.h"
-using namespace cv;
-
-static void printGLString(const char *name, GLenum s)
-{
-  const char *v = (const char *)glGetString(s);
-  LOGI("GL %s = %s\n", name, v);
-}
-
-static void checkGlError(const char* op)
-{
-  for (GLint error = glGetError(); error; error = glGetError())
-  {
-    LOGI("after %s() glError (0x%x)\n", op, error);
-  }
-}
-
-static const char gVertexShader[] = "attribute vec4 a_position;   \n"
-  "attribute vec2 a_texCoord;   \n"
-  "varying vec2 v_texCoord;     \n"
-  "void main()                  \n"
-  "{                            \n"
-  "   gl_Position = a_position; \n"
-  "   v_texCoord = a_texCoord;  \n"
-  "}                            \n";
-
-static const char gFragmentShader[] = "precision mediump float;                            \n"
-  "varying vec2 v_texCoord;                            \n"
-  "uniform sampler2D s_texture;                        \n"
-  "void main()                                         \n"
-  "{                                                   \n"
-  "  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
-  "}                                                   \n";
-
-
-GLuint glcamera::createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int width, int height, int channels)
-{
-
-  // Bind the texture
-  glActiveTexture(GL_TEXTURE0);
-  checkGlError("glActiveTexture");
-  // Bind the texture object
-  glBindTexture(GL_TEXTURE_2D, _textureid);
-  checkGlError("glBindTexture");
-
-  GLenum format;
-  switch (channels)
-  {
-    case 3:
-#if ANDROID
-      format = GL_RGB;
-#else
-      format = GL_BGR;
-#endif
-      break;
-    case 1:
-      format = GL_LUMINANCE;
-      break;
-    case 4:
-      format = GL_RGBA;
-      break;
-  }
-  // Load the texture
-  glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, pixels);
-
-  checkGlError("glTexImage2D");
-#if ANDROID
-  // Set the filtering mode
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-#else
-  /* Linear Filtering */
-  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-#endif
-
-  return _textureid;
-
-}
-
-GLuint glcamera::loadShader(GLenum shaderType, const char* pSource)
-{
-  GLuint shader = 0;
-#if __ANDROID__
-  shader = glCreateShader(shaderType);
-  if (shader)
-  {
-    glShaderSource(shader, 1, &pSource, NULL);
-    glCompileShader(shader);
-    GLint compiled = 0;
-    glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
-    if (!compiled)
-    {
-      GLint infoLen = 0;
-      glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
-      if (infoLen)
-      {
-        char* buf = (char*)malloc(infoLen);
-        if (buf)
-        {
-          glGetShaderInfoLog(shader, infoLen, NULL, buf);
-          LOGE("Could not compile shader %d:\n%s\n",
-              shaderType, buf);
-          free(buf);
-        }
-        glDeleteShader(shader);
-        shader = 0;
-      }
-    }
-  }
-#endif
-  return shader;
-}
-
-GLuint glcamera::createProgram(const char* pVertexSource, const char* pFragmentSource)
-{
-#if __ANDROID__
-  GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
-  if (!vertexShader)
-  {
-    return 0;
-  }
-
-  GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
-  if (!pixelShader)
-  {
-    return 0;
-  }
-
-  GLuint program = glCreateProgram();
-  if (program)
-  {
-    glAttachShader(program, vertexShader);
-    checkGlError("glAttachShader");
-    glAttachShader(program, pixelShader);
-    checkGlError("glAttachShader");
-    glLinkProgram(program);
-    GLint linkStatus = GL_FALSE;
-    glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
-    if (linkStatus != GL_TRUE)
-    {
-      GLint bufLength = 0;
-      glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
-      if (bufLength)
-      {
-        char* buf = (char*)malloc(bufLength);
-        if (buf)
-        {
-          glGetProgramInfoLog(program, bufLength, NULL, buf);
-          LOGE("Could not link program:\n%s\n", buf);
-          free(buf);
-        }
-      }
-      glDeleteProgram(program);
-      program = 0;
-    }
-  }
-  return program;
-#else
-  return 0;
-#endif
-}
-void  glcamera::clear(){
-  nimg = Mat();
-}
-//GLuint textureID;
-
-bool glcamera::setupGraphics(int w, int h)
-{
-//  printGLString("Version", GL_VERSION);
-//  printGLString("Vendor", GL_VENDOR);
-//  printGLString("Renderer", GL_RENDERER);
-//  printGLString("Extensions", GL_EXTENSIONS);
-
-#if __ANDROID__
-  gProgram = createProgram(gVertexShader, gFragmentShader);
-  if (!gProgram)
-  {
-    LOGE("Could not create program.");
-    return false;
-  }
-
-  gvPositionHandle = glGetAttribLocation(gProgram, "a_position");
-  gvTexCoordHandle = glGetAttribLocation(gProgram, "a_texCoord");
-  gvSamplerHandle = glGetAttribLocation(gProgram, "s_texture");
-
-  // Use tightly packed data
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-  // Generate a texture object
-  glGenTextures(1, &textureID);
-
-  glViewport(0, 0, w, h);
-#endif
-  return true;
-}
-
-void glcamera::renderFrame()
-{
-
-#if __ANDROID__
-  GLfloat vVertices[] = {-1.0f, 1.0f, 0.0f, // Position 0
-                         0.0f, 0.0f, // TexCoord 0
-                         -1.0f, -1.0f, 0.0f, // Position 1
-                         0.0f, img_h, // TexCoord 1
-                         1.0f, -1.0f, 0.0f, // Position 2
-                         img_w, img_h, // TexCoord 2
-                         1.0f, 1.0f, 0.0f, // Position 3
-                         img_w, 0.0f // TexCoord 3
-      };
-  GLushort indices[] = {0, 1, 2, 0, 2, 3};
-  GLsizei stride = 5 * sizeof(GLfloat); // 3 for position, 2 for texture
-
-  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-  checkGlError("glClearColor");
-
-  glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
-  checkGlError("glClear");
-
-  if(nimg.empty())return;
-
-  glUseProgram(gProgram);
-  checkGlError("glUseProgram");
-
-  // Load the vertex position
-  glVertexAttribPointer(gvPositionHandle, 3, GL_FLOAT, GL_FALSE, stride, vVertices);
-  // Load the texture coordinate
-  glVertexAttribPointer(gvTexCoordHandle, 2, GL_FLOAT, GL_FALSE, stride, &vVertices[3]);
-
-  glEnableVertexAttribArray(gvPositionHandle);
-  glEnableVertexAttribArray(gvTexCoordHandle);
-
-  // Bind the texture
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, textureID);
-
-  // Set the sampler texture unit to 0
-  glUniform1i(gvSamplerHandle, 0);
-
-  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
-#endif
-  //checkGlError("glVertexAttribPointer");
-  //glEnableVertexAttribArray(gvPositionHandle);
-  //checkGlError("glEnableVertexAttribArray");
-  //glDrawArrays(GL_TRIANGLES, 0, 3);
-  //checkGlError("glDrawArrays");
-}
-
-void glcamera::init(int width, int height)
-{
-  newimage = false;
-  nimg = Mat();
-  setupGraphics(width, height);
-
-}
-
-void glcamera::step()
-{
-  if (newimage && !nimg.empty())
-  {
-
-    textureID = createSimpleTexture2D(textureID, nimg.ptr<unsigned char> (0), nimg.cols, nimg.rows, nimg.channels());
-    newimage = false;
-  }
-  renderFrame();
-
-}
-#define NEAREST_POW2(x)( std::ceil(std::log(x)/0.69315) )
-void glcamera::setTextureImage(const Mat& img)
-{
-  int p = NEAREST_POW2(img.cols/2); //subsample by 2
-  //int sz = std::pow(2, p);
-
-  // Size size(sz, sz);
-  Size size(256, 256);
-  img_w = 1;
-  img_h = 1;
-  if (nimg.cols != size.width)
-    LOGI_STREAM( "using texture of size: (" << size.width << " , " << size.height << ") image size is: (" << img.cols << " , " << img.rows << ")");
-  nimg.create(size, img.type());
-#if SUBREGION_NPO2
-  cv::Rect roi(0, 0, img.cols/2, img.rows/2);
-  cv::Mat nimg_sub = nimg(roi);
-  //img.copyTo(nimg_sub);
-  img_w = (img.cols/2)/float(sz);
-  img_h = (img.rows/2)/float(sz);
-  cv::resize(img,nimg_sub,nimg_sub.size(),0,0,CV_INTER_NN);
-#else
-  cv::resize(img, nimg, nimg.size(), 0, 0, CV_INTER_NN);
-#endif
-  newimage = true;
-}
-
-void glcamera::drawMatToGL(int idx, image_pool* pool)
-{
-
-  Mat img = pool->getImage(idx);
-
-  if (img.empty())
-    return; //no image at input_idx!
-
-  setTextureImage(img);
-
-}
-
-glcamera::glcamera() :
-  newimage(false)
-{
-  LOGI("glcamera constructor");
-}
-glcamera::~glcamera()
-{
-  LOGI("glcamera destructor");
-}
-
diff --git a/android/android-opencv/jni/glcamera.i b/android/android-opencv/jni/glcamera.i
deleted file mode 100644
index 2fd2a53ff6..0000000000
--- a/android/android-opencv/jni/glcamera.i
+++ /dev/null
@@ -1,44 +0,0 @@
-
-%typemap(javaimports) glcamera "
-/** a class for doing the native rendering of images
-this class renders using GL2 es, the native ndk version
-This class is used by the GL2CameraViewer to do the rendering,
-and is inspired by the gl2 example in the ndk samples
-*/"
-
-
-
-%javamethodmodifiers glcamera::init"
-  /**  should be called onSurfaceChanged by the GLSurfaceView that is using this
-  	*  as the drawing engine
-  	* @param width the width of the surface view that this will be drawing to
-    * @param width the height of the surface view that this will be drawing to
-  	*
-    */
-  public";
-  
-%javamethodmodifiers glcamera::step"
-  /**  should be called by GLSurfaceView.Renderer in the onDrawFrame method, as it
-  handles the rendering of the opengl scene, and requires that the opengl context be
-  valid.
- 
-  	*
-    */
-  public";
-%javamethodmodifiers glcamera::drawMatToGL"
-  /** copies an image from a pool and queues it for drawing in opengl.
-  	*  this does transformation into power of two texture sizes
-  	* @param idx the image index to copy
-    * @param pool the image_pool to look up the image from
-  	*
-    */
-  public";
-  
-class glcamera {
-public:
-     void init(int width, int height);
-     void step();
-     void drawMatToGL(int idx, image_pool* pool);
-     void clear();
-};
-
diff --git a/android/android-opencv/jni/image_pool.cpp b/android/android-opencv/jni/image_pool.cpp
deleted file mode 100644
index c7a6720905..0000000000
--- a/android/android-opencv/jni/image_pool.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "image_pool.h"
-
-#include "yuv420sp2rgb.h"
-
-#include "android_logger.h"
-
-#include <opencv2/imgproc/imgproc.hpp>
-
-#include <cstdlib>
-#include <jni.h>
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved);
-//
-//JNIEXPORT jobject JNICALL Java_com_opencv_jni_opencvJNI_getBitmapBuffer(
-//		JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_);
-
-
-JNIEXPORT void JNICALL Java_com_opencv_jni_opencvJNI_addYUVtoPool(JNIEnv *, jclass, jlong, jobject, jbyteArray, jint,
-    jint, jint, jboolean);
-
-#ifdef __cplusplus
-}
-#endif
-
-using namespace cv;
-
-JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
-{
-  JNIEnv *env;
-  LOGI("JNI_OnLoad called for opencv");
-  return JNI_VERSION_1_4;
-}
-
-JNIEXPORT void JNICALL Java_com_opencv_jni_opencvJNI_addYUVtoPool(JNIEnv * env, jclass thiz, jlong ppool,
-    jobject _jpool, jbyteArray jbuffer, jint jidx,
-    jint jwidth, jint jheight, jboolean jgrey)
-{
-  int buff_height = jheight + (jheight / 2);
-  Size buff_size(jwidth, buff_height);
-  image_pool *pool = (image_pool *)ppool;
-
-  Mat mat = pool->getYUV(jidx);
-  //create is smart and only copies if the buffer size is different
-  mat.create(buff_size, CV_8UC1);
-  {
-    uchar* buff = mat.ptr<uchar> (0);
-    jsize sz = env->GetArrayLength(jbuffer);
-    //http://elliotth.blogspot.com/2007/03/optimizing-jni-array-access.html
-    env->GetByteArrayRegion(jbuffer, 0, sz, (jbyte*)buff);
-  }
-  pool->addYUVMat(jidx, mat);
-
-  Mat color;
-  if (jgrey)
-  {
-    Mat grey = pool->getGrey(jidx);
-    color = grey;
-  }
-  else
-  {
-    color = pool->getImage(jidx);
-    pool->convertYUVtoColor(jidx, color);
-  }
-  pool->addImage(jidx, color);
-}
-
-image_pool::image_pool()
-{
-
-}
-
-image_pool::~image_pool()
-{
-
-}
-
-Mat image_pool::getImage(int i)
-{
-  return imagesmap[i];
-}
-Mat image_pool::getGrey(int i)
-{
-  Mat tm = yuvImagesMap[i];
-  if (tm.empty())
-    return tm;
-  return tm(Range(0, tm.rows * (2.0f / 3)), Range::all());
-}
-Mat image_pool::getYUV(int i)
-{
-  return yuvImagesMap[i];
-}
-void image_pool::addYUVMat(int i, Mat mat)
-{
-  yuvImagesMap[i] = mat;
-}
-void image_pool::addImage(int i, Mat mat)
-{
-  imagesmap[i] = mat;
-}
-
-void image_pool::convertYUVtoColor(int i, cv::Mat& out)
-{
-  Mat yuv = getYUV(i);
-  if (yuv.empty())
-    return;
-  int width = yuv.cols;
-  int height = yuv.rows * (2.0f / 3);
-  out.create(height, width, CV_8UC3);
-  const unsigned char* buff = yuv.ptr<unsigned char> (0);
-  unsigned char* out_buff = out.ptr<unsigned char> (0);
-  color_convert_common(buff, buff + width * height, width, height, out_buff, false);
-}
-
-void copyMatToBuffer(char* buffer, const cv::Mat& mat)
-{
-  memcpy(buffer, mat.data, mat.rows * mat.cols * mat.step1());
-}
-void copyBufferToMat(cv::Mat& mat, const char* buffer)
-{
-  memcpy(mat.data, buffer, mat.rows * mat.cols * mat.step1());
-}
-
-void RGB2BGR(const Mat& in, Mat& out)
-{
-  cvtColor(in, out, CV_RGB2BGR);
-}
diff --git a/android/android-opencv/jni/image_pool.i b/android/android-opencv/jni/image_pool.i
deleted file mode 100644
index b81e64a958..0000000000
--- a/android/android-opencv/jni/image_pool.i
+++ /dev/null
@@ -1,51 +0,0 @@
-
-
-%typemap(javaimports) image_pool "
-/** image_pool is used for keeping track of a pool of native images.  It stores images as cv::Mat's and
-references them by an index.  It allows one to get a pointer to an underlying mat, and handles memory deletion.*/"
-
-
-%javamethodmodifiers image_pool::getImage"
-  /** gets a pointer to a stored image, by an index.  If the index is new, returns a null pointer
-  	* @param idx the index in the pool that is associated with a cv::Mat
-  	* @return the pointer to a cv::Mat, null pointer if the given idx is novel
-    */
-  public";
-  
-  
-%javamethodmodifiers image_pool::deleteImage"
-  /** deletes the image from the pool
-  	* @param idx the index in the pool that is associated with a cv::Mat
-    */
-  public";
-  
-  
-  
-%javamethodmodifiers addYUVtoPool"
-  /** adds a yuv
-  	* @param idx the index in the pool that is associated with a cv::Mat
-    */
-  public";
-  
-%include "various.i"
-
-
-%apply (char* BYTE) { (char *data)}; //byte[] to char*
-
-
-%native (addYUVtoPool) void addYUVtoPool(image_pool* pool, char* data,int idx, int width, int height, bool grey);
-
-
-
-
-%feature("director") image_pool;
-class image_pool {
-public:
-	Mat getGrey(int i);
-	Mat getImage(int i);
-	void addImage(int i, Mat mat);
-	void convertYUVtoColor(int i, Mat& out);
-};
-
-void RGB2BGR(const Mat& in, Mat& out);
-
diff --git a/android/android-opencv/jni/include/Calibration.h b/android/android-opencv/jni/include/Calibration.h
deleted file mode 100644
index 6e0eef3bc4..0000000000
--- a/android/android-opencv/jni/include/Calibration.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Processor.h
- *
- *  Created on: Jun 13, 2010
- *      Author: ethan
- */
-
-#ifndef PROCESSOR_H_
-#define PROCESSOR_H_
-
-#include <opencv2/core/core.hpp>
-#include <opencv2/features2d/features2d.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/calib3d/calib3d.hpp>
-
-#include <vector>
-
-#include "image_pool.h"
-
-#define DETECT_FAST 0
-#define DETECT_STAR 1
-#define DETECT_SURF 2
-
-class Calibration
-{
-public:
-
-  Calibration();
-  virtual ~Calibration();
-
-  bool detectAndDrawChessboard(int idx, image_pool* pool);
-
-  void resetChess();
-
-  int getNumberDetectedChessboards();
-
-  void calibrate(const char* filename);
-
-  void drawText(int idx, image_pool* pool, const char* text);
-
-  cv::Size patternsize;
-private:
-  std::vector<cv::KeyPoint> keypoints;
-
-  std::vector<std::vector<cv::Point2f> > imagepoints;
-
-  cv::Mat K;
-  cv::Mat distortion;
-  cv::Size imgsize;
-
-};
-
-#endif /* PROCESSOR_H_ */
diff --git a/android/android-opencv/jni/include/android_logger.h b/android/android-opencv/jni/include/android_logger.h
deleted file mode 100644
index 09f8dc3512..0000000000
--- a/android/android-opencv/jni/include/android_logger.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-#include <iostream>
-#include <sstream>
-
-#define  LOG_TAG    "libopencv"
-#if ANDROID
-#include <android/log.h>
-#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
-#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
-#else
-#include <cstdio>
-#define  LOGI(...)  printf("info:");printf("%s:",LOG_TAG); fprintf(stdout,__VA_ARGS__);printf("\n");
-#define  LOGE(...)  printf("error:");printf("%s:",LOG_TAG); fprintf(stderr,__VA_ARGS__);printf("\n");
-#endif
-
-#ifndef LOGI_STREAM
-#define  LOGI_STREAM(x)  {std::stringstream ss; ss << x; LOGI("%s",ss.str().c_str());}
-#endif
-#define  LOGE_STREAM(x)  {std::stringstream ss; ss << x; LOGE("%s",ss.str().c_str());}
diff --git a/android/android-opencv/jni/include/glcamera.h b/android/android-opencv/jni/include/glcamera.h
deleted file mode 100644
index e7c021a429..0000000000
--- a/android/android-opencv/jni/include/glcamera.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef GLCAMERA_H_
-#define GLCAMERA_H_
-#include <opencv2/core/core.hpp>
-
-#ifdef __ANDROID__
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#else
-#include <GL/gl.h>
-#include <GL/glu.h>
-#endif
-
-#include "image_pool.h"
-
-class glcamera
-{
-public:
-
-  glcamera();
-  ~glcamera();
-  void init(int width, int height);
-  void step();
-
-  void drawMatToGL(int idx, image_pool* pool);
-  void drawMatToGL(const cv::Mat& img);
-  void setTextureImage(const cv::Mat& img);
-
-  void clear();
-
-private:
-  GLuint createSimpleTexture2D(GLuint _textureid, GLubyte* pixels, int width, int height, int channels);
-  GLuint loadShader(GLenum shaderType, const char* pSource);
-  GLuint
-  createProgram(const char* pVertexSource, const char* pFragmentSource);
-  bool setupGraphics(int w, int h);
-  void renderFrame();
-  cv::Mat nimg;
-  bool newimage;
-  GLuint textureID;
-
-  GLuint gProgram;
-  GLuint gvPositionHandle;
-
-  GLuint gvTexCoordHandle;
-  GLuint gvSamplerHandle;
-  float img_w, img_h;
-};
-#endif
diff --git a/android/android-opencv/jni/include/image_pool.h b/android/android-opencv/jni/include/image_pool.h
deleted file mode 100644
index d32eb479c9..0000000000
--- a/android/android-opencv/jni/include/image_pool.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef IMAGE_POOL_H_ANDROID_KDJFKJ
-#define IMAGE_POOL_H_ANDROID_KDJFKJ
-#include <opencv2/core/core.hpp>
-#include <map>
-
-
-
-class image_pool
-{
-
-public:
-  image_pool();
-  ~image_pool();
-  cv::Mat getImage(int i);
-  cv::Mat getGrey(int i);
-  cv::Mat getYUV(int i);
-
-  int getCount()
-  {
-    return imagesmap.size();
-  }
-
-  /** Adds a mat at the given index - will not do a deep copy, just images[i] = mat
-   *
-   */
-  void addImage(int i, cv::Mat mat);
-
-  /** this function stores the given matrix in the the yuvImagesMap. Also,
-   * after this call getGrey will work, as the grey image is just the top
-   * half of the YUV mat.
-   *
-   * \param i index to store yuv image at
-   * \param mat the yuv matrix to store
-   */
-  void addYUVMat(int i, cv::Mat mat);
-
-  void convertYUVtoColor(int i, cv::Mat& out);
-
-  //	int addYUV(uchar* buffer, int size, int width, int height, bool grey,int idx);
-  //
-  //	void getBitmap(int * outintarray, int size, int idx);
-private:
-  std::map<int, cv::Mat> imagesmap;
-  std::map<int, cv::Mat> yuvImagesMap;
-
-};
-
-void copyMatToBuffer(char* buffer, const cv::Mat& mat);
-void copyBufferToMat(cv::Mat& mat, const char* buffer);
-void RGB2BGR(const cv::Mat& in, cv::Mat& out);
-#endif
diff --git a/android/android-opencv/jni/include/yuv2rgb.h b/android/android-opencv/jni/include/yuv2rgb.h
deleted file mode 100644
index 9b7535c661..0000000000
--- a/android/android-opencv/jni/include/yuv2rgb.h
+++ /dev/null
@@ -1,147 +0,0 @@
-/* YUV-> RGB conversion code.
- *
- * Copyright (C) 2008-9 Robin Watts (robin@wss.co.uk) for Pinknoise
- * Productions Ltd.
- *
- * Licensed under the GNU GPL. If you need it under another license, contact
- * me and ask.
- *
- *  This program is free software ; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation ; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program ; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- */
-
-#ifndef YUV2RGB_H
-
-#define YUV2RGB_H
-
-/* Define these to something appropriate in your build */
-typedef unsigned int   uint32_t;
-typedef signed   int   int32_t;
-typedef unsigned short uint16_t;
-typedef unsigned char  uint8_t;
-
-extern const uint32_t yuv2rgb565_table[];
-extern const uint32_t yuv2bgr565_table[];
-
-void yuv420_2_rgb565(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv422_2_rgb565(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv444_2_rgb565(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv420_2_rgb888(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv422_2_rgb888(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv444_2_rgb888(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither);
-
-void yuv420_2_rgb8888(uint8_t  *dst_ptr,
-                const uint8_t  *y_ptr,
-                const uint8_t  *u_ptr,
-                const uint8_t  *v_ptr,
-                      int32_t   width,
-                      int32_t   height,
-                      int32_t   y_span,
-                      int32_t   uv_span,
-                      int32_t   dst_span,
-                const uint32_t *tables,
-                      int32_t   dither);
-
-void yuv422_2_rgb8888(uint8_t  *dst_ptr,
-                const uint8_t  *y_ptr,
-                const uint8_t  *u_ptr,
-                const uint8_t  *v_ptr,
-                      int32_t   width,
-                      int32_t   height,
-                      int32_t   y_span,
-                      int32_t   uv_span,
-                      int32_t   dst_span,
-                const uint32_t *tables,
-                      int32_t   dither);
-
-void yuv444_2_rgb8888(uint8_t  *dst_ptr,
-                const uint8_t  *y_ptr,
-                const uint8_t  *u_ptr,
-                const uint8_t  *v_ptr,
-                      int32_t   width,
-                      int32_t   height,
-                      int32_t   y_span,
-                      int32_t   uv_span,
-                      int32_t   dst_span,
-                const uint32_t *tables,
-                      int32_t   dither);
-
-
-#endif /* YUV2RGB_H */
diff --git a/android/android-opencv/jni/include/yuv420sp2rgb.h b/android/android-opencv/jni/include/yuv420sp2rgb.h
deleted file mode 100644
index fcfc49cc4b..0000000000
--- a/android/android-opencv/jni/include/yuv420sp2rgb.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef YUV420SP2RGB_H
-#define YUV420SP2RGB_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void color_convert_common(
-    const unsigned char *pY, const unsigned char *pUV,
-    int width, int height, unsigned char *buffer,
-    int grey);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/android/android-opencv/jni/nocopy.i b/android/android-opencv/jni/nocopy.i
deleted file mode 100644
index 23e685fd83..0000000000
--- a/android/android-opencv/jni/nocopy.i
+++ /dev/null
@@ -1,36 +0,0 @@
-/* 
- * int *INTARRAY  typemaps. 
- * These are input typemaps for mapping a Java int[] array to a C int array.
- * Note that as a Java array is used and thus passeed by reference, the C routine 
- * can return data to Java via the parameter.
- *
- * Example usage wrapping:
- *   void foo((int *INTARRAY, int INTARRAYSIZE);
- *  
- * Java usage:
- *   byte b[] = new byte[20];
- *   modulename.foo(b);
- */
-
-%typemap(in) (int *INTARRAY, int INTARRAYSIZE) {
-    $1 = (int *) JCALL2(GetIntArrayElements, jenv, $input, 0); 
-    jsize sz = JCALL1(GetArrayLength, jenv, $input);
-    $2 = (int)sz;
-}
-
-%typemap(argout) (int *INTARRAY, int INTARRAYSIZE) {
-    JCALL3(ReleaseIntArrayElements, jenv, $input, (jint *) $1, 0); 
-}
-
-
-/* Prevent default freearg typemap from being used */
-%typemap(freearg) (int *INTARRAY, int INTARRAYSIZE) ""
-
-%typemap(jni) (int *INTARRAY, int INTARRAYSIZE) "jintArray"
-%typemap(jtype) (int *INTARRAY, int INTARRAYSIZE) "int[]"
-%typemap(jstype) (int *INTARRAY, int INTARRAYSIZE) "int[]"
-%typemap(javain) (int *INTARRAY, int INTARRAYSIZE) "$javainput"
-
-
-
-
diff --git a/android/android-opencv/jni/yuv2rgb16tab.c b/android/android-opencv/jni/yuv2rgb16tab.c
deleted file mode 100644
index f9f6a14053..0000000000
--- a/android/android-opencv/jni/yuv2rgb16tab.c
+++ /dev/null
@@ -1,802 +0,0 @@
-/* YUV-> RGB conversion code.
- *
- * Copyright (C) 2008-9 Robin Watts (robin@wss.co.uk) for Pinknoise
- * Productions Ltd.
- *
- * Licensed under the GNU GPL. If you need it under another license, contact
- * me and ask.
- *
- *  This program is free software ; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation ; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program ; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- */
-
-/* For BREW or Symbian you might need to make this static const rather than
- * just const, and introduce a function to get the address. */
-
-#include "yuv2rgb.h"
-
-const uint32_t yuv2rgb565_table[256*3] =
-{
-	/* y_table */
-        0x7FFFFFEDU,
-        0x7FFFFFEFU,
-        0x7FFFFFF0U,
-        0x7FFFFFF1U,
-        0x7FFFFFF2U,
-        0x7FFFFFF3U,
-        0x7FFFFFF4U,
-        0x7FFFFFF6U,
-        0x7FFFFFF7U,
-        0x7FFFFFF8U,
-        0x7FFFFFF9U,
-        0x7FFFFFFAU,
-        0x7FFFFFFBU,
-        0x7FFFFFFDU,
-        0x7FFFFFFEU,
-        0x7FFFFFFFU,
-        0x80000000U,
-        0x80400801U,
-        0x80A01002U,
-        0x80E01803U,
-        0x81202805U,
-        0x81803006U,
-        0x81C03807U,
-        0x82004008U,
-        0x82604809U,
-        0x82A0500AU,
-        0x82E0600CU,
-        0x8340680DU,
-        0x8380700EU,
-        0x83C0780FU,
-        0x84208010U,
-        0x84608811U,
-        0x84A09813U,
-        0x8500A014U,
-        0x8540A815U,
-        0x8580B016U,
-        0x85E0B817U,
-        0x8620C018U,
-        0x8660D01AU,
-        0x86C0D81BU,
-        0x8700E01CU,
-        0x8740E81DU,
-        0x87A0F01EU,
-        0x87E0F81FU,
-        0x88210821U,
-        0x88811022U,
-        0x88C11823U,
-        0x89012024U,
-        0x89412825U,
-        0x89A13026U,
-        0x89E14028U,
-        0x8A214829U,
-        0x8A81502AU,
-        0x8AC1582BU,
-        0x8B01602CU,
-        0x8B61682DU,
-        0x8BA1782FU,
-        0x8BE18030U,
-        0x8C418831U,
-        0x8C819032U,
-        0x8CC19833U,
-        0x8D21A034U,
-        0x8D61B036U,
-        0x8DA1B837U,
-        0x8E01C038U,
-        0x8E41C839U,
-        0x8E81D03AU,
-        0x8EE1D83BU,
-        0x8F21E83DU,
-        0x8F61F03EU,
-        0x8FC1F83FU,
-        0x90020040U,
-        0x90420841U,
-        0x90A21042U,
-        0x90E22044U,
-        0x91222845U,
-        0x91823046U,
-        0x91C23847U,
-        0x92024048U,
-        0x92624849U,
-        0x92A2504AU,
-        0x92E2604CU,
-        0x9342684DU,
-        0x9382704EU,
-        0x93C2784FU,
-        0x94228050U,
-        0x94628851U,
-        0x94A29853U,
-        0x9502A054U,
-        0x9542A855U,
-        0x9582B056U,
-        0x95E2B857U,
-        0x9622C058U,
-        0x9662D05AU,
-        0x96C2D85BU,
-        0x9702E05CU,
-        0x9742E85DU,
-        0x97A2F05EU,
-        0x97E2F85FU,
-        0x98230861U,
-        0x98831062U,
-        0x98C31863U,
-        0x99032064U,
-        0x99632865U,
-        0x99A33066U,
-        0x99E34068U,
-        0x9A434869U,
-        0x9A83506AU,
-        0x9AC3586BU,
-        0x9B23606CU,
-        0x9B63686DU,
-        0x9BA3786FU,
-        0x9BE38070U,
-        0x9C438871U,
-        0x9C839072U,
-        0x9CC39873U,
-        0x9D23A074U,
-        0x9D63B076U,
-        0x9DA3B877U,
-        0x9E03C078U,
-        0x9E43C879U,
-        0x9E83D07AU,
-        0x9EE3D87BU,
-        0x9F23E87DU,
-        0x9F63F07EU,
-        0x9FC3F87FU,
-        0xA0040080U,
-        0xA0440881U,
-        0xA0A41082U,
-        0xA0E42084U,
-        0xA1242885U,
-        0xA1843086U,
-        0xA1C43887U,
-        0xA2044088U,
-        0xA2644889U,
-        0xA2A4588BU,
-        0xA2E4608CU,
-        0xA344688DU,
-        0xA384708EU,
-        0xA3C4788FU,
-        0xA4248090U,
-        0xA4649092U,
-        0xA4A49893U,
-        0xA504A094U,
-        0xA544A895U,
-        0xA584B096U,
-        0xA5E4B897U,
-        0xA624C098U,
-        0xA664D09AU,
-        0xA6C4D89BU,
-        0xA704E09CU,
-        0xA744E89DU,
-        0xA7A4F09EU,
-        0xA7E4F89FU,
-        0xA82508A1U,
-        0xA88510A2U,
-        0xA8C518A3U,
-        0xA90520A4U,
-        0xA96528A5U,
-        0xA9A530A6U,
-        0xA9E540A8U,
-        0xAA4548A9U,
-        0xAA8550AAU,
-        0xAAC558ABU,
-        0xAB2560ACU,
-        0xAB6568ADU,
-        0xABA578AFU,
-        0xAC0580B0U,
-        0xAC4588B1U,
-        0xAC8590B2U,
-        0xACE598B3U,
-        0xAD25A0B4U,
-        0xAD65B0B6U,
-        0xADA5B8B7U,
-        0xAE05C0B8U,
-        0xAE45C8B9U,
-        0xAE85D0BAU,
-        0xAEE5D8BBU,
-        0xAF25E8BDU,
-        0xAF65F0BEU,
-        0xAFC5F8BFU,
-        0xB00600C0U,
-        0xB04608C1U,
-        0xB0A610C2U,
-        0xB0E620C4U,
-        0xB12628C5U,
-        0xB18630C6U,
-        0xB1C638C7U,
-        0xB20640C8U,
-        0xB26648C9U,
-        0xB2A658CBU,
-        0xB2E660CCU,
-        0xB34668CDU,
-        0xB38670CEU,
-        0xB3C678CFU,
-        0xB42680D0U,
-        0xB46690D2U,
-        0xB4A698D3U,
-        0xB506A0D4U,
-        0xB546A8D5U,
-        0xB586B0D6U,
-        0xB5E6B8D7U,
-        0xB626C8D9U,
-        0xB666D0DAU,
-        0xB6C6D8DBU,
-        0xB706E0DCU,
-        0xB746E8DDU,
-        0xB7A6F0DEU,
-        0xB7E6F8DFU,
-        0xB82708E1U,
-        0xB88710E2U,
-        0xB8C718E3U,
-        0xB90720E4U,
-        0xB96728E5U,
-        0xB9A730E6U,
-        0xB9E740E8U,
-        0xBA4748E9U,
-        0xBA8750EAU,
-        0xBAC758EBU,
-        0xBB2760ECU,
-        0xBB6768EDU,
-        0xBBA778EFU,
-        0xBC0780F0U,
-        0xBC4788F1U,
-        0xBC8790F2U,
-        0xBCE798F3U,
-        0xBD27A0F4U,
-        0xBD67B0F6U,
-        0xBDC7B8F7U,
-        0xBE07C0F8U,
-        0xBE47C8F9U,
-        0xBEA7D0FAU,
-        0xBEE7D8FBU,
-        0xBF27E8FDU,
-        0xBF87F0FEU,
-        0xBFC7F8FFU,
-        0xC0080100U,
-        0xC0480901U,
-        0xC0A81102U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-        0xC0E82104U,
-	/* u_table */
-        0x0C400103U,
-        0x0C200105U,
-        0x0C200107U,
-        0x0C000109U,
-        0x0BE0010BU,
-        0x0BC0010DU,
-        0x0BA0010FU,
-        0x0BA00111U,
-        0x0B800113U,
-        0x0B600115U,
-        0x0B400117U,
-        0x0B400119U,
-        0x0B20011BU,
-        0x0B00011DU,
-        0x0AE0011FU,
-        0x0AE00121U,
-        0x0AC00123U,
-        0x0AA00125U,
-        0x0A800127U,
-        0x0A600129U,
-        0x0A60012BU,
-        0x0A40012DU,
-        0x0A20012FU,
-        0x0A000131U,
-        0x0A000132U,
-        0x09E00134U,
-        0x09C00136U,
-        0x09A00138U,
-        0x09A0013AU,
-        0x0980013CU,
-        0x0960013EU,
-        0x09400140U,
-        0x09400142U,
-        0x09200144U,
-        0x09000146U,
-        0x08E00148U,
-        0x08C0014AU,
-        0x08C0014CU,
-        0x08A0014EU,
-        0x08800150U,
-        0x08600152U,
-        0x08600154U,
-        0x08400156U,
-        0x08200158U,
-        0x0800015AU,
-        0x0800015CU,
-        0x07E0015EU,
-        0x07C00160U,
-        0x07A00162U,
-        0x07A00164U,
-        0x07800166U,
-        0x07600168U,
-        0x0740016AU,
-        0x0720016CU,
-        0x0720016EU,
-        0x07000170U,
-        0x06E00172U,
-        0x06C00174U,
-        0x06C00176U,
-        0x06A00178U,
-        0x0680017AU,
-        0x0660017CU,
-        0x0660017EU,
-        0x06400180U,
-        0x06200182U,
-        0x06000184U,
-        0x05E00185U,
-        0x05E00187U,
-        0x05C00189U,
-        0x05A0018BU,
-        0x0580018DU,
-        0x0580018FU,
-        0x05600191U,
-        0x05400193U,
-        0x05200195U,
-        0x05200197U,
-        0x05000199U,
-        0x04E0019BU,
-        0x04C0019DU,
-        0x04C0019FU,
-        0x04A001A1U,
-        0x048001A3U,
-        0x046001A5U,
-        0x044001A7U,
-        0x044001A9U,
-        0x042001ABU,
-        0x040001ADU,
-        0x03E001AFU,
-        0x03E001B1U,
-        0x03C001B3U,
-        0x03A001B5U,
-        0x038001B7U,
-        0x038001B9U,
-        0x036001BBU,
-        0x034001BDU,
-        0x032001BFU,
-        0x032001C1U,
-        0x030001C3U,
-        0x02E001C5U,
-        0x02C001C7U,
-        0x02A001C9U,
-        0x02A001CBU,
-        0x028001CDU,
-        0x026001CFU,
-        0x024001D1U,
-        0x024001D3U,
-        0x022001D5U,
-        0x020001D7U,
-        0x01E001D8U,
-        0x01E001DAU,
-        0x01C001DCU,
-        0x01A001DEU,
-        0x018001E0U,
-        0x016001E2U,
-        0x016001E4U,
-        0x014001E6U,
-        0x012001E8U,
-        0x010001EAU,
-        0x010001ECU,
-        0x00E001EEU,
-        0x00C001F0U,
-        0x00A001F2U,
-        0x00A001F4U,
-        0x008001F6U,
-        0x006001F8U,
-        0x004001FAU,
-        0x004001FCU,
-        0x002001FEU,
-        0x00000200U,
-        0xFFE00202U,
-        0xFFC00204U,
-        0xFFC00206U,
-        0xFFA00208U,
-        0xFF80020AU,
-        0xFF60020CU,
-        0xFF60020EU,
-        0xFF400210U,
-        0xFF200212U,
-        0xFF000214U,
-        0xFF000216U,
-        0xFEE00218U,
-        0xFEC0021AU,
-        0xFEA0021CU,
-        0xFEA0021EU,
-        0xFE800220U,
-        0xFE600222U,
-        0xFE400224U,
-        0xFE200226U,
-        0xFE200228U,
-        0xFE000229U,
-        0xFDE0022BU,
-        0xFDC0022DU,
-        0xFDC0022FU,
-        0xFDA00231U,
-        0xFD800233U,
-        0xFD600235U,
-        0xFD600237U,
-        0xFD400239U,
-        0xFD20023BU,
-        0xFD00023DU,
-        0xFCE0023FU,
-        0xFCE00241U,
-        0xFCC00243U,
-        0xFCA00245U,
-        0xFC800247U,
-        0xFC800249U,
-        0xFC60024BU,
-        0xFC40024DU,
-        0xFC20024FU,
-        0xFC200251U,
-        0xFC000253U,
-        0xFBE00255U,
-        0xFBC00257U,
-        0xFBC00259U,
-        0xFBA0025BU,
-        0xFB80025DU,
-        0xFB60025FU,
-        0xFB400261U,
-        0xFB400263U,
-        0xFB200265U,
-        0xFB000267U,
-        0xFAE00269U,
-        0xFAE0026BU,
-        0xFAC0026DU,
-        0xFAA0026FU,
-        0xFA800271U,
-        0xFA800273U,
-        0xFA600275U,
-        0xFA400277U,
-        0xFA200279U,
-        0xFA20027BU,
-        0xFA00027CU,
-        0xF9E0027EU,
-        0xF9C00280U,
-        0xF9A00282U,
-        0xF9A00284U,
-        0xF9800286U,
-        0xF9600288U,
-        0xF940028AU,
-        0xF940028CU,
-        0xF920028EU,
-        0xF9000290U,
-        0xF8E00292U,
-        0xF8E00294U,
-        0xF8C00296U,
-        0xF8A00298U,
-        0xF880029AU,
-        0xF860029CU,
-        0xF860029EU,
-        0xF84002A0U,
-        0xF82002A2U,
-        0xF80002A4U,
-        0xF80002A6U,
-        0xF7E002A8U,
-        0xF7C002AAU,
-        0xF7A002ACU,
-        0xF7A002AEU,
-        0xF78002B0U,
-        0xF76002B2U,
-        0xF74002B4U,
-        0xF74002B6U,
-        0xF72002B8U,
-        0xF70002BAU,
-        0xF6E002BCU,
-        0xF6C002BEU,
-        0xF6C002C0U,
-        0xF6A002C2U,
-        0xF68002C4U,
-        0xF66002C6U,
-        0xF66002C8U,
-        0xF64002CAU,
-        0xF62002CCU,
-        0xF60002CEU,
-        0xF60002CFU,
-        0xF5E002D1U,
-        0xF5C002D3U,
-        0xF5A002D5U,
-        0xF5A002D7U,
-        0xF58002D9U,
-        0xF56002DBU,
-        0xF54002DDU,
-        0xF52002DFU,
-        0xF52002E1U,
-        0xF50002E3U,
-        0xF4E002E5U,
-        0xF4C002E7U,
-        0xF4C002E9U,
-        0xF4A002EBU,
-        0xF48002EDU,
-        0xF46002EFU,
-        0xF46002F1U,
-        0xF44002F3U,
-        0xF42002F5U,
-        0xF40002F7U,
-        0xF3E002F9U,
-        0xF3E002FBU,
-	/* v_table */
-        0x1A09A000U,
-        0x19E9A800U,
-        0x19A9B800U,
-        0x1969C800U,
-        0x1949D000U,
-        0x1909E000U,
-        0x18C9E800U,
-        0x18A9F800U,
-        0x186A0000U,
-        0x182A1000U,
-        0x180A2000U,
-        0x17CA2800U,
-        0x17AA3800U,
-        0x176A4000U,
-        0x172A5000U,
-        0x170A6000U,
-        0x16CA6800U,
-        0x168A7800U,
-        0x166A8000U,
-        0x162A9000U,
-        0x160AA000U,
-        0x15CAA800U,
-        0x158AB800U,
-        0x156AC000U,
-        0x152AD000U,
-        0x14EAE000U,
-        0x14CAE800U,
-        0x148AF800U,
-        0x146B0000U,
-        0x142B1000U,
-        0x13EB2000U,
-        0x13CB2800U,
-        0x138B3800U,
-        0x134B4000U,
-        0x132B5000U,
-        0x12EB6000U,
-        0x12CB6800U,
-        0x128B7800U,
-        0x124B8000U,
-        0x122B9000U,
-        0x11EBA000U,
-        0x11ABA800U,
-        0x118BB800U,
-        0x114BC000U,
-        0x112BD000U,
-        0x10EBE000U,
-        0x10ABE800U,
-        0x108BF800U,
-        0x104C0000U,
-        0x100C1000U,
-        0x0FEC2000U,
-        0x0FAC2800U,
-        0x0F8C3800U,
-        0x0F4C4000U,
-        0x0F0C5000U,
-        0x0EEC5800U,
-        0x0EAC6800U,
-        0x0E6C7800U,
-        0x0E4C8000U,
-        0x0E0C9000U,
-        0x0DEC9800U,
-        0x0DACA800U,
-        0x0D6CB800U,
-        0x0D4CC000U,
-        0x0D0CD000U,
-        0x0CCCD800U,
-        0x0CACE800U,
-        0x0C6CF800U,
-        0x0C4D0000U,
-        0x0C0D1000U,
-        0x0BCD1800U,
-        0x0BAD2800U,
-        0x0B6D3800U,
-        0x0B2D4000U,
-        0x0B0D5000U,
-        0x0ACD5800U,
-        0x0AAD6800U,
-        0x0A6D7800U,
-        0x0A2D8000U,
-        0x0A0D9000U,
-        0x09CD9800U,
-        0x098DA800U,
-        0x096DB800U,
-        0x092DC000U,
-        0x090DD000U,
-        0x08CDD800U,
-        0x088DE800U,
-        0x086DF800U,
-        0x082E0000U,
-        0x07EE1000U,
-        0x07CE1800U,
-        0x078E2800U,
-        0x076E3800U,
-        0x072E4000U,
-        0x06EE5000U,
-        0x06CE5800U,
-        0x068E6800U,
-        0x064E7800U,
-        0x062E8000U,
-        0x05EE9000U,
-        0x05CE9800U,
-        0x058EA800U,
-        0x054EB800U,
-        0x052EC000U,
-        0x04EED000U,
-        0x04AED800U,
-        0x048EE800U,
-        0x044EF000U,
-        0x042F0000U,
-        0x03EF1000U,
-        0x03AF1800U,
-        0x038F2800U,
-        0x034F3000U,
-        0x030F4000U,
-        0x02EF5000U,
-        0x02AF5800U,
-        0x028F6800U,
-        0x024F7000U,
-        0x020F8000U,
-        0x01EF9000U,
-        0x01AF9800U,
-        0x016FA800U,
-        0x014FB000U,
-        0x010FC000U,
-        0x00EFD000U,
-        0x00AFD800U,
-        0x006FE800U,
-        0x004FF000U,
-        0x00100000U,
-        0xFFD01000U,
-        0xFFB01800U,
-        0xFF702800U,
-        0xFF303000U,
-        0xFF104000U,
-        0xFED05000U,
-        0xFEB05800U,
-        0xFE706800U,
-        0xFE307000U,
-        0xFE108000U,
-        0xFDD09000U,
-        0xFD909800U,
-        0xFD70A800U,
-        0xFD30B000U,
-        0xFD10C000U,
-        0xFCD0D000U,
-        0xFC90D800U,
-        0xFC70E800U,
-        0xFC30F000U,
-        0xFBF10000U,
-        0xFBD11000U,
-        0xFB911800U,
-        0xFB712800U,
-        0xFB313000U,
-        0xFAF14000U,
-        0xFAD14800U,
-        0xFA915800U,
-        0xFA516800U,
-        0xFA317000U,
-        0xF9F18000U,
-        0xF9D18800U,
-        0xF9919800U,
-        0xF951A800U,
-        0xF931B000U,
-        0xF8F1C000U,
-        0xF8B1C800U,
-        0xF891D800U,
-        0xF851E800U,
-        0xF831F000U,
-        0xF7F20000U,
-        0xF7B20800U,
-        0xF7921800U,
-        0xF7522800U,
-        0xF7123000U,
-        0xF6F24000U,
-        0xF6B24800U,
-        0xF6925800U,
-        0xF6526800U,
-        0xF6127000U,
-        0xF5F28000U,
-        0xF5B28800U,
-        0xF5729800U,
-        0xF552A800U,
-        0xF512B000U,
-        0xF4F2C000U,
-        0xF4B2C800U,
-        0xF472D800U,
-        0xF452E800U,
-        0xF412F000U,
-        0xF3D30000U,
-        0xF3B30800U,
-        0xF3731800U,
-        0xF3532800U,
-        0xF3133000U,
-        0xF2D34000U,
-        0xF2B34800U,
-        0xF2735800U,
-        0xF2336800U,
-        0xF2137000U,
-        0xF1D38000U,
-        0xF1B38800U,
-        0xF1739800U,
-        0xF133A800U,
-        0xF113B000U,
-        0xF0D3C000U,
-        0xF093C800U,
-        0xF073D800U,
-        0xF033E000U,
-        0xF013F000U,
-        0xEFD40000U,
-        0xEF940800U,
-        0xEF741800U,
-        0xEF342000U,
-        0xEEF43000U,
-        0xEED44000U,
-        0xEE944800U,
-        0xEE745800U,
-        0xEE346000U,
-        0xEDF47000U,
-        0xEDD48000U,
-        0xED948800U,
-        0xED549800U,
-        0xED34A000U,
-        0xECF4B000U,
-        0xECD4C000U,
-        0xEC94C800U,
-        0xEC54D800U,
-        0xEC34E000U,
-        0xEBF4F000U,
-        0xEBB50000U,
-        0xEB950800U,
-        0xEB551800U,
-        0xEB352000U,
-        0xEAF53000U,
-        0xEAB54000U,
-        0xEA954800U,
-        0xEA555800U,
-        0xEA156000U,
-        0xE9F57000U,
-        0xE9B58000U,
-        0xE9958800U,
-        0xE9559800U,
-        0xE915A000U,
-        0xE8F5B000U,
-        0xE8B5C000U,
-        0xE875C800U,
-        0xE855D800U,
-        0xE815E000U,
-        0xE7F5F000U,
-        0xE7B60000U,
-        0xE7760800U,
-        0xE7561800U,
-        0xE7162000U,
-        0xE6D63000U,
-        0xE6B64000U,
-        0xE6764800U,
-        0xE6365800U
-};
diff --git a/android/android-opencv/jni/yuv2rgb_neon.c b/android/android-opencv/jni/yuv2rgb_neon.c
deleted file mode 100644
index a845858ab7..0000000000
--- a/android/android-opencv/jni/yuv2rgb_neon.c
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-#include "yuv420sp2rgb.h"
-#include <arm_neon.h>
-#include <stdlib.h>
-
-/* this source file should only be compiled by Android.mk when targeting
- * the armeabi-v7a ABI, and should be built in NEON mode
- */
-void fir_filter_neon_intrinsics(short *output, const short* input, const short* kernel, int width, int kernelSize)
-{
-#if 1
-  int nn, offset = -kernelSize / 2;
-
-  for (nn = 0; nn < width; nn++)
-  {
-    int mm, sum = 0;
-    int32x4_t sum_vec = vdupq_n_s32(0);
-    for (mm = 0; mm < kernelSize / 4; mm++)
-    {
-      int16x4_t kernel_vec = vld1_s16(kernel + mm * 4);
-      int16x4_t input_vec = vld1_s16(input + (nn + offset + mm * 4));
-      sum_vec = vmlal_s16(sum_vec, kernel_vec, input_vec);
-    }
-
-    sum += vgetq_lane_s32(sum_vec, 0);
-    sum += vgetq_lane_s32(sum_vec, 1);
-    sum += vgetq_lane_s32(sum_vec, 2);
-    sum += vgetq_lane_s32(sum_vec, 3);
-
-    if (kernelSize & 3)
-    {
-      for (mm = kernelSize - (kernelSize & 3); mm < kernelSize; mm++)
-        sum += kernel[mm] * input[nn + offset + mm];
-    }
-
-    output[nn] = (short)((sum + 0x8000) >> 16);
-  }
-#else /* for comparison purposes only */
-  int nn, offset = -kernelSize/2;
-  for (nn = 0; nn < width; nn++)
-  {
-    int sum = 0;
-    int mm;
-    for (mm = 0; mm < kernelSize; mm++)
-    {
-      sum += kernel[mm]*input[nn+offset+mm];
-    }
-    output[n] = (short)((sum + 0x8000) >> 16);
-  }
-#endif
-}
-
-/*
- YUV 4:2:0 image with a plane of 8 bit Y samples followed by an interleaved
- U/V plane containing 8 bit 2x2 subsampled chroma samples.
- except the interleave order of U and V is reversed.
-
- H V
- Y Sample Period      1 1
- U (Cb) Sample Period 2 2
- V (Cr) Sample Period 2 2
- */
-
-/*
- size of a char:
- find . -name limits.h -exec grep CHAR_BIT {} \;
- */
-
-#ifndef max
-#define max(a,b) ({typeof(a) _a = (a); typeof(b) _b = (b); _a > _b ? _a : _b; })
-#define min(a,b) ({typeof(a) _a = (a); typeof(b) _b = (b); _a < _b ? _a : _b; })
-#endif
-
-#define bytes_per_pixel 2
-#define LOAD_Y(i,j) (pY + i * width + j)
-#define LOAD_V(i,j) (pUV + (i / 2) * width + bytes_per_pixel * (j / 2))
-#define LOAD_U(i,j) (pUV + (i / 2) * width + bytes_per_pixel * (j / 2)+1)
-
-const uint8_t ZEROS[8] = {220,220, 220, 220, 220, 220, 220, 220};
-const uint8_t Y_SUBS[8] = {16, 16, 16, 16, 16, 16, 16, 16};
-const uint8_t UV_SUBS[8] = {128, 128, 128, 128, 128, 128, 128, 128};
-
-const uint32_t UV_MULS[] = {833, 400, 833, 400};
-
-void color_convert_common(unsigned char *pY, unsigned char *pUV, int width, int height, unsigned char *buffer, int grey)
-{
-
-  int i, j;
-  int nR, nG, nB;
-  int nY, nU, nV;
-  unsigned char *out = buffer;
-  int offset = 0;
-
-  uint8x8_t Y_SUBvec = vld1_u8(Y_SUBS);
-  uint8x8_t UV_SUBvec = vld1_u8(UV_SUBS); // v,u,v,u v,u,v,u
-  uint32x4_t UV_MULSvec = vld1q_u32(UV_MULS);
-  uint8x8_t ZEROSvec =vld1_u8(ZEROS);
-
-  uint32_t UVvec_int[8];
-  if (grey)
-  {
-    memcpy(out, pY, width * height * sizeof(unsigned char));
-  }
-  else
-    // YUV 4:2:0
-    for (i = 0; i < height; i++)
-    {
-      for (j = 0; j < width; j += 8)
-      {
-        //        nY = *(pY + i * width + j);
-        //        nV = *(pUV + (i / 2) * width + bytes_per_pixel * (j / 2));
-        //        nU = *(pUV + (i / 2) * width + bytes_per_pixel * (j / 2) + 1);
-
-        uint8x8_t nYvec = vld1_u8(LOAD_Y(i,j));
-        uint8x8_t nUVvec = vld1_u8(LOAD_V(i,j)); // v,u,v,u v,u,v,u
-
-        nYvec = vmul_u8(nYvec, vcle_u8(nYvec,ZEROSvec));
-
-        // Yuv Convert
-        //        nY -= 16;
-        //        nU -= 128;
-        //        nV -= 128;
-
-        //        nYvec = vsub_u8(nYvec, Y_SUBvec);
-        //        nUVvec = vsub_u8(nYvec, UV_SUBvec);
-
-        uint16x8_t nYvec16 = vmovl_u8(vsub_u8(nYvec, Y_SUBvec));
-        uint16x8_t nUVvec16 = vmovl_u8(vsub_u8(nYvec, UV_SUBvec));
-
-        uint16x4_t Y_low4 = vget_low_u16(nYvec16);
-        uint16x4_t Y_high4 = vget_high_u16(nYvec16);
-        uint16x4_t UV_low4 = vget_low_u16(nUVvec16);
-        uint16x4_t UV_high4 = vget_high_u16(nUVvec16);
-
-        uint32x4_t UV_low4_int = vmovl_u16(UV_low4);
-        uint32x4_t UV_high4_int = vmovl_u16(UV_high4);
-
-        uint32x4_t Y_low4_int = vmull_n_u16(Y_low4, 1192);
-        uint32x4_t Y_high4_int = vmull_n_u16(Y_high4, 1192);
-
-        uint32x4x2_t UV_uzp = vuzpq_u32(UV_low4_int, UV_high4_int);
-
-        uint32x2_t Vl = vget_low_u32(UV_uzp.val[0]);// vld1_u32(UVvec_int);
-        uint32x2_t Vh = vget_high_u32(UV_uzp.val[0]);//vld1_u32(UVvec_int + 2);
-
-        uint32x2x2_t Vll_ = vzip_u32(Vl, Vl);
-        uint32x4_t* Vll = (uint32x4_t*)(&Vll_);
-
-        uint32x2x2_t Vhh_ = vzip_u32(Vh, Vh);
-        uint32x4_t* Vhh = (uint32x4_t*)(&Vhh_);
-
-        uint32x2_t Ul =  vget_low_u32(UV_uzp.val[1]);
-        uint32x2_t Uh =  vget_high_u32(UV_uzp.val[1]);
-
-        uint32x2x2_t Ull_ = vzip_u32(Ul, Ul);
-        uint32x4_t* Ull = (uint32x4_t*)(&Ull_);
-
-        uint32x2x2_t Uhh_ = vzip_u32(Uh, Uh);
-        uint32x4_t* Uhh = (uint32x4_t*)(&Uhh_);
-
-        uint32x4_t B_int_low = vmlaq_n_u32(Y_low4_int, *Ull, 2066); //multiply by scalar accum
-        uint32x4_t B_int_high = vmlaq_n_u32(Y_high4_int, *Uhh, 2066); //multiply by scalar accum
-        uint32x4_t G_int_low = vsubq_u32(Y_low4_int, vmlaq_n_u32(vmulq_n_u32(*Vll, 833), *Ull, 400));
-        uint32x4_t G_int_high = vsubq_u32(Y_high4_int, vmlaq_n_u32(vmulq_n_u32(*Vhh, 833), *Uhh, 400));
-        uint32x4_t R_int_low = vmlaq_n_u32(Y_low4_int, *Vll, 1634); //multiply by scalar accum
-        uint32x4_t R_int_high = vmlaq_n_u32(Y_high4_int, *Vhh, 1634); //multiply by scalar accum
-
-        B_int_low = vshrq_n_u32 (B_int_low, 10);
-        B_int_high = vshrq_n_u32 (B_int_high, 10);
-        G_int_low = vshrq_n_u32 (G_int_low, 10);
-        G_int_high = vshrq_n_u32 (G_int_high, 10);
-        R_int_low = vshrq_n_u32 (R_int_low, 10);
-        R_int_high = vshrq_n_u32 (R_int_high, 10);
-
-
-        uint8x8x3_t RGB;
-        RGB.val[0] = vmovn_u16(vcombine_u16(vqmovn_u32 (R_int_low),vqmovn_u32 (R_int_high)));
-        RGB.val[1] = vmovn_u16(vcombine_u16(vqmovn_u32 (G_int_low),vqmovn_u32 (G_int_high)));
-        RGB.val[2] = vmovn_u16(vcombine_u16(vqmovn_u32 (B_int_low),vqmovn_u32 (B_int_high)));
-
-        vst3_u8 (out+i*width*3 + j*3, RGB);
-      }
-    }
-
-}
-
diff --git a/android/android-opencv/jni/yuv420rgb888.s b/android/android-opencv/jni/yuv420rgb888.s
deleted file mode 100644
index 570ccc7d2c..0000000000
--- a/android/android-opencv/jni/yuv420rgb888.s
+++ /dev/null
@@ -1,379 +0,0 @@
-; YUV-> RGB conversion code Copyright (C) 2008 Robin Watts (robin;wss.co.uk).
-;
-; Licensed under the GPL. If you need it under another license, contact me
-; and ask.
-;
-;  This program is free software ; you can redistribute it and/or modify
-;  it under the terms of the GNU General Public License as published by
-;  the Free Software Foundation ; either version 2 of the License, or
-;  (at your option) any later version.
-;
-;  This program is distributed in the hope that it will be useful,
-;  but WITHOUT ANY WARRANTY ; without even the implied warranty of
-;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;  GNU General Public License for more details.
-;
-;  You should have received a copy of the GNU General Public License
-;  along with this program ; if not, write to the Free Software
-;  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-;
-;
-; The algorithm used here is based heavily on one created by Sophie Wilson
-; of Acorn/e-14/Broadcomm. Many thanks.
-;
-; Additional tweaks (in the fast fixup code) are from Paul Gardiner.
-;
-; The old implementation of YUV -> RGB did:
-;
-; R = CLAMP((Y-16)*1.164 +           1.596*V)
-; G = CLAMP((Y-16)*1.164 - 0.391*U - 0.813*V)
-; B = CLAMP((Y-16)*1.164 + 2.018*U          )
-;
-; We're going to bend that here as follows:
-;
-; R = CLAMP(y +           1.596*V)
-; G = CLAMP(y - 0.383*U - 0.813*V)
-; B = CLAMP(y + 1.976*U          )
-;
-; where y = 0               for       Y <=  16,
-;       y = (  Y-16)*1.164, for  16 < Y <= 239,
-;       y = (239-16)*1.164, for 239 < Y
-;
-; i.e. We clamp Y to the 16 to 239 range (which it is supposed to be in
-; anyway). We then pick the B_U factor so that B never exceeds 511. We then
-; shrink the G_U factor in line with that to avoid a colour shift as much as
-; possible.
-;
-; We're going to use tables to do it faster, but rather than doing it using
-; 5 tables as as the above suggests, we're going to do it using just 3.
-;
-; We do this by working in parallel within a 32 bit word, and using one
-; table each for Y U and V.
-;
-; Source Y values are    0 to 255, so    0.. 260 after scaling
-; Source U values are -128 to 127, so  -49.. 49(G), -253..251(B) after
-; Source V values are -128 to 127, so -204..203(R), -104..103(G) after
-;
-; So total summed values:
-; -223 <= R <= 481, -173 <= G <= 431, -253 <= B < 511
-;
-; We need to pack R G and B into a 32 bit word, and because of Bs range we
-; need 2 bits above the valid range of B to detect overflow, and another one
-; to detect the sense of the overflow. We therefore adopt the following
-; representation:
-;
-; osGGGGGgggggosBBBBBbbbosRRRRRrrr
-;
-; Each such word breaks down into 3 ranges.
-;
-; osGGGGGggggg   osBBBBBbbb   osRRRRRrrr
-;
-; Thus we have 8 bits for each B and R table entry, and 10 bits for G (good
-; as G is the most noticable one). The s bit for each represents the sign,
-; and o represents the overflow.
-;
-; For R and B we pack the table by taking the 11 bit representation of their
-; values, and toggling bit 10 in the U and V tables.
-;
-; For the green case we calculate 4*G (thus effectively using 10 bits for the
-; valid range) truncate to 12 bits. We toggle bit 11 in the Y table.
-
-; Theorarm library
-; Copyright (C) 2009 Robin Watts for Pinknoise Productions Ltd
-
-	AREA	|.text|, CODE, READONLY
-
-	EXPORT	yuv420_2_rgb888
-	EXPORT	yuv420_2_rgb888_PROFILE
-
-; void yuv420_2_rgb565
-;  uint8_t *dst_ptr
-;  uint8_t *y_ptr
-;  uint8_t *u_ptr
-;  uint8_t *v_ptr
-;  int      width
-;  int      height
-;  int      y_span
-;  int      uv_span
-;  int      dst_span
-;  int     *tables
-;  int      dither
-
-CONST_flags
-	DCD	0x40080100
-yuv420_2_rgb888
-	; r0 = dst_ptr
-	; r1 = y_ptr
-	; r2 = u_ptr
-	; r3 = v_ptr
-	; <> = width
-	; <> = height
-	; <> = y_span
-	; <> = uv_span
-	; <> = dst_span
-	; <> = y_table
-	; <> = dither
-	STMFD	r13!,{r4-r11,r14}
-
-	LDR	r8, [r13,#10*4]		; r8 = height
-	LDR	r10,[r13,#11*4]		; r10= y_span
-	LDR	r9, [r13,#13*4]		; r9 = dst_span
-	LDR	r14,[r13,#14*4]		; r14= y_table
-	LDR	r5, CONST_flags
-	LDR	r11,[r13,#9*4]		; r11= width
-	ADD	r4, r14, #256*4
-	SUBS	r8, r8, #1
-	BLT	end
-	BEQ	trail_row1
-yloop1
-	SUB	r8, r8, r11,LSL #16	; r8 = height-(width<<16)
-	ADDS	r8, r8, #1<<16		; if (width == 1)
-	BGE	trail_pair1		;    just do 1 column
-xloop1
-	LDRB	r11,[r2], #1		; r11 = u  = *u_ptr++
-	LDRB	r12,[r3], #1		; r12 = v  = *v_ptr++
-	LDRB	r7, [r1, r10]		; r7  = y2 = y_ptr[stride]
-	LDRB	r6, [r1], #1		; r6  = y0 = *y_ptr++
-	ADD	r12,r12,#512
-	LDR	r11,[r4, r11,LSL #2]	; r11 = u  = u_table[u]
-	LDR	r12,[r14,r12,LSL #2]	; r12 = v  = v_table[v]
-	LDR	r7, [r14,r7, LSL #2]	; r7  = y2 = y_table[y2]
-	LDR	r6, [r14,r6, LSL #2]	; r6  = y0 = y_table[y0]
-	ADD	r11,r11,r12		; r11 = uv = u+v
-
-	ADD	r7, r7, r11		; r7  = y2 + uv
-	ADD	r6, r6, r11		; r6  = y0 + uv
-	ANDS	r12,r7, r5
-	TSTEQ	r6, r5
-	BNE	fix101
-return101
-	; Store the bottom one first
-	ADD	r12,r0, r9
-	STRB	r7,[r12],#1		; Store R
-	MOV	r7, r7, ROR #22
-	STRB	r7,[r12],#1		; Store G
-	MOV	r7, r7, ROR #21
-	STRB	r7,[r12],#1		; Store B
-
-	; Then store the top one
-	STRB	r6,[r0], #1		; Store R
-	MOV	r6, r6, ROR #22
-	STRB	r6,[r0], #1		; Store G
-
-	LDRB	r7, [r1, r10]		; r7 = y3 = y_ptr[stride]
-	LDRB	r12,[r1], #1		; r12= y1 = *y_ptr++
-	MOV	r6, r6, ROR #21
-	LDR	r7, [r14, r7, LSL #2]	; r7 = y3 = y_table[y2]
-	LDR	r12,[r14, r12,LSL #2]	; r12= y1 = y_table[y0]
-	STRB	r6,[r0], #1		; Store B
-
-	ADD	r7, r7, r11		; r7  = y3 + uv
-	ADD	r6, r12,r11		; r6  = y1 + uv
-	ANDS	r12,r7, r5
-	TSTEQ	r6, r5
-	BNE	fix102
-return102
-	; Store the bottom one first
-	ADD	r12,r0, r9
-	STRB	r7,[r12],#1		; Store R
-	MOV	r7, r7, ROR #22
-	STRB	r7,[r12],#1		; Store G
-	MOV	r7, r7, ROR #21
-	STRB	r7,[r12],#1		; Store B
-
-	; Then store the top one
-	STRB	r6,[r0], #1		; Store R
-	MOV	r6, r6, ROR #22
-	STRB	r6,[r0], #1		; Store G
-	MOV	r6, r6, ROR #21
-	STRB	r6,[r0], #1		; Store B
-
-	ADDS	r8, r8, #2<<16
-	BLT	xloop1
-	MOVS	r8, r8, LSL #16		; Clear the top 16 bits of r8
-	MOV	r8, r8, LSR #16		; If the C bit is clear we still have
-	BCC	trail_pair1		; 1 more pixel pair to do
-end_xloop1
-	LDR	r11,[r13,#9*4]		; r11= width
-	LDR	r12,[r13,#12*4]		; r12= uv_stride
-	ADD	r0, r0, r9, LSL #1
-	SUB	r0, r0, r11,LSL #1
-	SUB	r0, r0, r11
-	ADD	r1, r1, r10,LSL #1
-	SUB	r1, r1, r11
-	SUB	r2, r2, r11,LSR #1
-	SUB	r3, r3, r11,LSR #1
-	ADD	r2, r2, r12
-	ADD	r3, r3, r12
-
-	SUBS	r8, r8, #2
-	BGT	yloop1
-
-	LDMLTFD	r13!,{r4-r11,pc}
-trail_row1
-	; We have a row of pixels left to do
-	SUB	r8, r8, r11,LSL #16	; r8 = height-(width<<16)
-	ADDS	r8, r8, #1<<16		; if (width == 1)
-	BGE	trail_pix1		;    just do 1 pixel
-xloop12
-	LDRB	r11,[r2], #1		; r11 = u  = *u_ptr++
-	LDRB	r12,[r3], #1		; r12 = v  = *v_ptr++
-	LDRB	r6, [r1], #1		; r6  = y0 = *y_ptr++
-	LDRB	r7, [r1], #1		; r7  = y1 = *y_ptr++
-	ADD	r12,r12,#512
-	LDR	r11,[r4, r11,LSL #2]	; r11 = u  = u_table[u]
-	LDR	r12,[r14,r12,LSL #2]	; r12 = v  = v_table[v]
-	LDR	r7, [r14,r7, LSL #2]	; r7  = y1 = y_table[y1]
-	LDR	r6, [r14,r6, LSL #2]	; r6  = y0 = y_table[y0]
-	ADD	r11,r11,r12		; r11 = uv = u+v
-
-	ADD	r6, r6, r11		; r6  = y0 + uv
-	ADD	r7, r7, r11		; r7  = y1 + uv
-	ANDS	r12,r7, r5
-	TSTEQ	r6, r5
-	BNE	fix104
-return104
-	; Store the bottom one first
-	STRB	r6,[r0], #1		; Store R
-	MOV	r6, r6, ROR #22
-	STRB	r6,[r0], #1		; Store G
-	MOV	r6, r6, ROR #21
-	STRB	r6,[r0], #1		; Store B
-
-	; Then store the top one
-	STRB	r7,[r0], #1		; Store R
-	MOV	r7, r7, ROR #22
-	STRB	r7,[r0], #1		; Store G
-	MOV	r7, r7, ROR #21
-	STRB	r7,[r0], #1		; Store B
-
-	ADDS	r8, r8, #2<<16
-	BLT	xloop12
-	MOVS	r8, r8, LSL #16		; Clear the top 16 bits of r8
-	MOV	r8, r8, LSR #16		; If the C bit is clear we still have
-	BCC	trail_pix1		; 1 more pixel pair to do
-end
-	LDMFD	r13!,{r4-r11,pc}
-trail_pix1
-	; We have a single extra pixel to do
-	LDRB	r11,[r2], #1		; r11 = u  = *u_ptr++
-	LDRB	r12,[r3], #1		; r12 = v  = *v_ptr++
-	LDRB	r6, [r1], #1		; r6  = y0 = *y_ptr++
-	ADD	r12,r12,#512
-	LDR	r11,[r4, r11,LSL #2]	; r11 = u  = u_table[u]
-	LDR	r12,[r14,r12,LSL #2]	; r12 = v  = v_table[v]
-	LDR	r6, [r14,r6, LSL #2]	; r6  = y0 = y_table[y0]
-	ADD	r11,r11,r12		; r11 = uv = u+v
-
-	ADD	r6, r6, r11		; r6  = y0 + uv
-	ANDS	r12,r6, r5
-	BNE	fix105
-return105
-	STRB	r6,[r0], #1		; Store R
-	MOV	r6, r6, ROR #22
-	STRB	r6,[r0], #1		; Store G
-	MOV	r6, r6, ROR #21
-	STRB	r6,[r0], #1		; Store B
-
-	LDMFD	r13!,{r4-r11,pc}
-
-trail_pair1
-	; We have a pair of pixels left to do
-	LDRB	r11,[r2]		; r11 = u  = *u_ptr++
-	LDRB	r12,[r3]		; r12 = v  = *v_ptr++
-	LDRB	r7, [r1, r10]		; r7  = y2 = y_ptr[stride]
-	LDRB	r6, [r1], #1		; r6  = y0 = *y_ptr++
-	ADD	r12,r12,#512
-	LDR	r11,[r4, r11,LSL #2]	; r11 = u  = u_table[u]
-	LDR	r12,[r14,r12,LSL #2]	; r12 = v  = v_table[v]
-	LDR	r7, [r14,r7, LSL #2]	; r7  = y2 = y_table[y2]
-	LDR	r6, [r14,r6, LSL #2]	; r6  = y0 = y_table[y0]
-	ADD	r11,r11,r12		; r11 = uv = u+v
-
-	ADD	r7, r7, r11		; r7  = y2 + uv
-	ADD	r6, r6, r11		; r6  = y0 + uv
-	ANDS	r12,r7, r5
-	TSTEQ	r6, r5
-	BNE	fix103
-return103
-	; Store the bottom one first
-	ADD	r12,r0, r9
-	STRB	r7,[r12],#1		; Store R
-	MOV	r7, r7, ROR #22
-	STRB	r7,[r12],#1		; Store G
-	MOV	r7, r7, ROR #21
-	STRB	r7,[r12],#1		; Store B
-
-	; Then store the top one
-	STRB	r6,[r0], #1		; Store R
-	MOV	r6, r6, ROR #22
-	STRB	r6,[r0], #1		; Store G
-	MOV	r6, r6, ROR #21
-	STRB	r6,[r0], #1		; Store B
-	B	end_xloop1
-fix101
-	; r7 and r6 are the values, at least one of which has overflowed
-	; r12 = r7 & mask = .s......s......s......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r7, r7, r12		; r7 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r7, LSR #1	; r12 = .o......o......o......
-	ADD	r7, r7, r12,LSR #8	; r7  = fixed value
-
-	AND	r12, r6, r5		; r12 = .S......S......S......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r6, r6, r12		; r6 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r6, LSR #1	; r12 = .o......o......o......
-	ADD	r6, r6, r12,LSR #8	; r6  = fixed value
-	B	return101
-fix102
-	; r7 and r6 are the values, at least one of which has overflowed
-	; r12 = r7 & mask = .s......s......s......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r7, r7, r12		; r7 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r7, LSR #1	; r12 = .o......o......o......
-	ADD	r7, r7, r12,LSR #8	; r7  = fixed value
-
-	AND	r12, r6, r5		; r12 = .S......S......S......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS..SSSSS.SSSSSS
-	ORR	r6, r6, r12		; r6 |= ..SSSSSS..SSSSS.SSSSSS
-	BIC	r12,r5, r6, LSR #1	; r12 = .o......o......o......
-	ADD	r6, r6, r12,LSR #8	; r6  = fixed value
-	B	return102
-fix103
-	; r7 and r6 are the values, at least one of which has overflowed
-	; r12 = r7 & mask = .s......s......s......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r7, r7, r12		; r7 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r7, LSR #1	; r12 = .o......o......o......
-	ADD	r7, r7, r12,LSR #8	; r7  = fixed value
-
-	AND	r12, r6, r5		; r12 = .S......S......S......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r6, r6, r12		; r6 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r6, LSR #1	; r12 = .o......o......o......
-	ADD	r6, r6, r12,LSR #8	; r6  = fixed value
-	B	return103
-fix104
-	; r7 and r6 are the values, at least one of which has overflowed
-	; r12 = r7 & mask = .s......s......s......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r7, r7, r12		; r7 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r7, LSR #1	; r12 = .o......o......o......
-	ADD	r7, r7, r12,LSR #8	; r7  = fixed value
-
-	AND	r12, r6, r5		; r12 = .S......S......S......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r6, r6, r12		; r6 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r6, LSR #1	; r12 = .o......o......o......
-	ADD	r6, r6, r12,LSR #8	; r6  = fixed value
-	B	return104
-fix105
-	; r6 is the value, which has has overflowed
-	; r12 = r7 & mask = .s......s......s......
-	SUB	r12,r12,r12,LSR #8	; r12 = ..SSSSSS.SSSSSS.SSSSSS
-	ORR	r6, r6, r12		; r6 |= ..SSSSSS.SSSSSS.SSSSSS
-	BIC	r12,r5, r6, LSR #1	; r12 = .o......o......o......
-	ADD	r6, r6, r12,LSR #8	; r6  = fixed value
-	B	return105
-
-	END
diff --git a/android/android-opencv/jni/yuv420rgb888c.c b/android/android-opencv/jni/yuv420rgb888c.c
deleted file mode 100644
index c7ec52e34e..0000000000
--- a/android/android-opencv/jni/yuv420rgb888c.c
+++ /dev/null
@@ -1,208 +0,0 @@
-/* YUV-> RGB conversion code. (YUV420 to RGB565)
- *
- * Copyright (C) 2008-9 Robin Watts (robin@wss.co.uk) for Pinknoise
- * Productions Ltd.
- *
- * Licensed under the GNU GPL. If you need it under another license, contact
- * me and ask.
- *
- *  This program is free software ; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation ; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program ; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
- *
- * The algorithm used here is based heavily on one created by Sophie Wilson
- * of Acorn/e-14/Broadcomm. Many thanks.
- *
- * Additional tweaks (in the fast fixup code) are from Paul Gardiner.
- *
- * The old implementation of YUV -> RGB did:
- *
- * R = CLAMP((Y-16)*1.164 +           1.596*V)
- * G = CLAMP((Y-16)*1.164 - 0.391*U - 0.813*V)
- * B = CLAMP((Y-16)*1.164 + 2.018*U          )
- *
- * We're going to bend that here as follows:
- *
- * R = CLAMP(y +           1.596*V)
- * G = CLAMP(y - 0.383*U - 0.813*V)
- * B = CLAMP(y + 1.976*U          )
- *
- * where y = 0               for       Y <=  16,
- *       y = (  Y-16)*1.164, for  16 < Y <= 239,
- *       y = (239-16)*1.164, for 239 < Y
- *
- * i.e. We clamp Y to the 16 to 239 range (which it is supposed to be in
- * anyway). We then pick the B_U factor so that B never exceeds 511. We then
- * shrink the G_U factor in line with that to avoid a colour shift as much as
- * possible.
- *
- * We're going to use tables to do it faster, but rather than doing it using
- * 5 tables as as the above suggests, we're going to do it using just 3.
- *
- * We do this by working in parallel within a 32 bit word, and using one
- * table each for Y U and V.
- *
- * Source Y values are    0 to 255, so    0.. 260 after scaling
- * Source U values are -128 to 127, so  -49.. 49(G), -253..251(B) after
- * Source V values are -128 to 127, so -204..203(R), -104..103(G) after
- *
- * So total summed values:
- * -223 <= R <= 481, -173 <= G <= 431, -253 <= B < 511
- *
- * We need to pack R G and B into a 32 bit word, and because of Bs range we
- * need 2 bits above the valid range of B to detect overflow, and another one
- * to detect the sense of the overflow. We therefore adopt the following
- * representation:
- *
- * osGGGGGgggggosBBBBBbbbosRRRRRrrr
- *
- * Each such word breaks down into 3 ranges.
- *
- * osGGGGGggggg   osBBBBBbbb   osRRRRRrrr
- *
- * Thus we have 8 bits for each B and R table entry, and 10 bits for G (good
- * as G is the most noticable one). The s bit for each represents the sign,
- * and o represents the overflow.
- *
- * For R and B we pack the table by taking the 11 bit representation of their
- * values, and toggling bit 10 in the U and V tables.
- *
- * For the green case we calculate 4*G (thus effectively using 10 bits for the
- * valid range) truncate to 12 bits. We toggle bit 11 in the Y table.
- */
-
-#include "yuv2rgb.h"
-
-enum
-{
-    FLAGS         = 0x40080100
-};
-
-#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)])
-#define READY(Y)    tables[Y]
-#define FIXUP(Y)                 \
-do {                             \
-    int tmp = (Y) & FLAGS;       \
-    if (tmp != 0)                \
-    {                            \
-        tmp  -= tmp>>8;          \
-        (Y)  |= tmp;             \
-        tmp   = FLAGS & ~(Y>>1); \
-        (Y)  += tmp>>8;          \
-    }                            \
-} while (0 == 1)
-
-#define STORE(Y,DSTPTR)           \
-do {                              \
-    uint32_t Y2       = (Y);      \
-    uint8_t  *DSTPTR2 = (DSTPTR); \
-    (DSTPTR2)[0] = (Y2);          \
-    (DSTPTR2)[1] = (Y2)>>22;      \
-    (DSTPTR2)[2] = (Y2)>>11;      \
-} while (0 == 1)
-
-void yuv420_2_rgb888(uint8_t  *dst_ptr,
-               const uint8_t  *y_ptr,
-               const uint8_t  *u_ptr,
-               const uint8_t  *v_ptr,
-                     int32_t   width,
-                     int32_t   height,
-                     int32_t   y_span,
-                     int32_t   uv_span,
-                     int32_t   dst_span,
-               const uint32_t *tables,
-                     int32_t   dither)
-{
-    height -= 1;
-    while (height > 0)
-    {
-        height -= width<<16;
-        height += 1<<16;
-        while (height < 0)
-        {
-            /* Do 2 column pairs */
-            uint32_t uv, y0, y1;
-
-            uv  = READUV(*u_ptr++,*v_ptr++);
-            y1  = uv + READY(y_ptr[y_span]);
-            y0  = uv + READY(*y_ptr++);
-            FIXUP(y1);
-            FIXUP(y0);
-            STORE(y1, &dst_ptr[dst_span]);
-            STORE(y0, dst_ptr);
-            dst_ptr += 3;
-            y1  = uv + READY(y_ptr[y_span]);
-            y0  = uv + READY(*y_ptr++);
-            FIXUP(y1);
-            FIXUP(y0);
-            STORE(y1, &dst_ptr[dst_span]);
-            STORE(y0, dst_ptr);
-            dst_ptr += 3;
-            height += (2<<16);
-        }
-        if ((height>>16) == 0)
-        {
-            /* Trailing column pair */
-            uint32_t uv, y0, y1;
-
-            uv = READUV(*u_ptr,*v_ptr);
-            y1 = uv + READY(y_ptr[y_span]);
-            y0 = uv + READY(*y_ptr++);
-            FIXUP(y1);
-            FIXUP(y0);
-            STORE(y0, &dst_ptr[dst_span]);
-            STORE(y1, dst_ptr);
-            dst_ptr += 3;
-        }
-        dst_ptr += dst_span*2-width*3;
-        y_ptr   += y_span*2-width;
-        u_ptr   += uv_span-(width>>1);
-        v_ptr   += uv_span-(width>>1);
-        height = (height<<16)>>16;
-        height -= 2;
-    }
-    if (height == 0)
-    {
-        /* Trail row */
-        height -= width<<16;
-        height += 1<<16;
-        while (height < 0)
-        {
-            /* Do a row pair */
-            uint32_t uv, y0, y1;
-
-            uv  = READUV(*u_ptr++,*v_ptr++);
-            y1  = uv + READY(*y_ptr++);
-            y0  = uv + READY(*y_ptr++);
-            FIXUP(y1);
-            FIXUP(y0);
-            STORE(y1, dst_ptr);
-            dst_ptr += 3;
-            STORE(y0, dst_ptr);
-            dst_ptr += 3;
-            height += (2<<16);
-        }
-        if ((height>>16) == 0)
-        {
-            /* Trailing pix */
-            uint32_t uv, y0;
-
-            uv = READUV(*u_ptr++,*v_ptr++);
-            y0 = uv + READY(*y_ptr++);
-            FIXUP(y0);
-            STORE(y0, dst_ptr);
-            dst_ptr += 3;
-        }
-    }
-}
diff --git a/android/android-opencv/jni/yuv420sp2rgb.c b/android/android-opencv/jni/yuv420sp2rgb.c
deleted file mode 100644
index ef2eea30da..0000000000
--- a/android/android-opencv/jni/yuv420sp2rgb.c
+++ /dev/null
@@ -1,156 +0,0 @@
-#include <string.h>
-#include <jni.h>
-
-#include <yuv420sp2rgb.h>
-#include <yuv2rgb.h>
-
-/*
- YUV 4:2:0 image with a plane of 8 bit Y samples followed by an interleaved
- U/V plane containing 8 bit 2x2 subsampled chroma samples.
- except the interleave order of U and V is reversed.
-
- H V
- Y Sample Period      1 1
- U (Cb) Sample Period 2 2
- V (Cr) Sample Period 2 2
- */
-
-/*
- size of a char:
- find . -name limits.h -exec grep CHAR_BIT {} \;
- */
-
-#ifndef max
-#define max(a,b) (a > b ? a : b )
-#define min(a,b) (a < b ? a : b )
-#endif
-enum
-{
-    FLAGS         = 0x40080100
-};
-
-#define READUV(U,V) (tables[256 + (U)] + tables[512 + (V)])
-#define READY(Y)    tables[Y]
-#define FIXUP(Y)                 \
-do {                             \
-    int tmp = (Y) & FLAGS;       \
-    if (tmp != 0)                \
-    {                            \
-        tmp  -= tmp>>8;          \
-        (Y)  |= tmp;             \
-        tmp   = FLAGS & ~(Y>>1); \
-        (Y)  += tmp>>8;          \
-    }                            \
-} while (0 == 1)
-
-#define STORE(Y,DSTPTR)           \
-do {                              \
-    uint32_t Y2       = (Y);      \
-    uint8_t  *DSTPTR2 = (DSTPTR); \
-    (DSTPTR2)[2] = (Y2);          \
-    (DSTPTR2)[1] = (Y2)>>22;      \
-    (DSTPTR2)[0] = (Y2)>>11;      \
-} while (0 == 1)
-
-typedef unsigned char byte;
-const int bytes_per_pixel = 2;
-void color_convert_common(const unsigned char *pY, const unsigned char *pUV, int width, int height,
-                          unsigned char *buffer, int grey)
-{
-#define LOOKUP 1
-#if ! LOOKUP
-  int nR, nG, nB;
-#endif
-  int dest_span = 3 * width;
-  unsigned char *out = buffer;
-  if (grey)
-  {
-    memcpy(out, pY, width * height * sizeof(unsigned char));
-  }
-  else
-  {
-
-#if LOOKUP
-    const uint32_t* tables = yuv2rgb565_table;
-    const byte* nY = pY;
-    const byte* nUV = pUV;
-    int idx = 0;
-    while (nY+width < pUV)
-    {
-      int y = (idx / width);
-      int x = (idx % width);
-      byte Y = *nY;
-      byte Y2 = nY[width];
-      byte V = *nUV;
-      byte U = *(nUV + 1);
-      /* Do 2 row pairs */
-      uint32_t uv, y0, y1;
-
-      uv = READUV(U,V);
-      y1 = uv + READY(Y);
-      y0 = uv + READY(Y2);
-      FIXUP(y1);
-      FIXUP(y0);
-      STORE(y1, &out[dest_span]);
-      STORE(y0, out);
-      out += 3;
-      Y = *(++nY);
-      Y2 = nY[width];
-      y1 = uv + READY(Y);
-      y0 = uv + READY(Y2);
-      FIXUP(y1);
-      FIXUP(y0);
-      STORE(y1, &out[dest_span]);
-      STORE(y0, out);
-      out += 3;
-      height += (2 << 16);
-      ++nY;
-      nUV = pUV + (y / 2) * width + 2 * (x / 2);
-      idx+=2;
-    }
-#else
-    const byte* nY = pY;
-    const byte* nUV = pUV;
-    int idx = 0;
-    while (nY < pUV)
-    {
-
-      int y = (idx / width);
-      int x = (idx % width);
-      int Y = *nY;
-      int V = *nUV;
-      int U = *(nUV + 1);
-
-      Y -= 16;
-      V -= 128;
-      U -= 128;
-      if (y < 0)
-      y = 0;
-
-      nB = (int)(1192 * Y + 2066 * U);
-      nG = (int)(1192 * Y - 833 * V - 400 * U);
-      nR = (int)(1192 * Y + 1634 * V);
-
-      nR = min(262143, max(0, nR));
-      nG = min(262143, max(0, nG));
-      nB = min(262143, max(0, nB));
-
-      nR >>= 10;
-      nR &= 0xff;
-      nG >>= 10;
-      nG &= 0xff;
-      nB >>= 10;
-      nB &= 0xff;
-
-      *(out++) = (unsigned char)nR;
-      *(out++) = (unsigned char)nG;
-      *(out++) = (unsigned char)nB;
-      nY += 1;
-      nUV = pUV + (y / 2) * width + 2 * (x / 2);
-      ++idx;
-    }
-#endif
-  }
-
-
-}
diff --git a/android/android-opencv/project_create.sh b/android/android-opencv/project_create.sh
deleted file mode 100755
index 0a1b6bd308..0000000000
--- a/android/android-opencv/project_create.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-#this generates an ant based cli build of the android-jni project
-android update project --name android-opencv \
---path .
diff --git a/android/android-opencv/res/drawable-mdpi/cameraback.jpg b/android/android-opencv/res/drawable-mdpi/cameraback.jpg
deleted file mode 100644
index b53ffd4891..0000000000
Binary files a/android/android-opencv/res/drawable-mdpi/cameraback.jpg and /dev/null differ
diff --git a/android/android-opencv/res/layout/calibrationviewer.xml b/android/android-opencv/res/layout/calibrationviewer.xml
deleted file mode 100644
index 00dea195c3..0000000000
--- a/android/android-opencv/res/layout/calibrationviewer.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-  xmlns:android="http://schemas.android.com/apk/res/android"
-  android:layout_width="fill_parent"
-  android:layout_height="fill_parent"
-  android:orientation="vertical"
-  android:gravity="center_vertical|center_horizontal">
-   <TextView android:scrollbars="vertical" android:id="@+id/calibtext" android:text="" android:layout_width="wrap_content" 
- android:layout_height="wrap_content" android:padding="20dip"/>
-
-</LinearLayout>
diff --git a/android/android-opencv/res/layout/camera.xml b/android/android-opencv/res/layout/camera.xml
deleted file mode 100644
index 560e3d429a..0000000000
--- a/android/android-opencv/res/layout/camera.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-	android:layout_width="fill_parent" android:layout_height="fill_parent"
-	android:background="@drawable/cameraback">
-	<!--<SurfaceView-->
-	<com.opencv.camera.NativePreviewer
-		android:id="@+id/nativepreviewer" android:layout_width="400dip"
-		android:layout_height="300dip" android:layout_alignParentLeft="true"
-		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
-		android:layout_marginRight="20dip" />
-	<LinearLayout android:id="@+id/glview_layout"
-		android:layout_width="400dip" android:layout_height="300dip"
-		android:layout_alignParentLeft="true" android:layout_margin="20dip"
-		android:gravity="center_horizontal|center_vertical"
-		android:layout_marginRight="20dip">
-	</LinearLayout>
-	<LinearLayout android:layout_width="wrap_content"
-		android:layout_height="fill_parent" android:orientation="vertical"
-		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
-		android:layout_alignParentRight="true">
-		<ImageButton android:src="@android:drawable/ic_menu_camera"
-			android:id="@+id/button_capture" android:layout_width="60dip"
-			android:layout_height="60dip" android:layout_marginBottom="10dip"></ImageButton>
-			<ImageButton android:src="@android:drawable/ic_menu_preferences"
-			android:id="@+id/button_camera_settings" android:layout_width="60dip"
-			android:layout_height="60dip" android:layout_marginBottom="10dip"></ImageButton>
-	</LinearLayout>
-</RelativeLayout>
diff --git a/android/android-opencv/res/layout/camerasettings.xml b/android/android-opencv/res/layout/camerasettings.xml
deleted file mode 100644
index 4366ad396d..0000000000
--- a/android/android-opencv/res/layout/camerasettings.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-	android:layout_width="fill_parent" android:layout_height="fill_parent"
-	android:orientation="vertical" android:gravity="center_vertical|center_horizontal">
-	<TextView android:text="@string/settings_text"
-		android:autoLink="web" android:layout_width="wrap_content"
-		android:layout_height="wrap_content" android:padding="20dip" />
-		
-	<LinearLayout android:id="@+id/LinearLayout01"
-		android:layout_width="wrap_content" android:layout_height="wrap_content"
-		android:gravity="center_vertical">
-		<TextView android:layout_width="wrap_content"
-			android:layout_height="wrap_content" android:text="@string/image_size_prompt" />
-		<Spinner android:id="@+id/image_size" android:layout_width="fill_parent"
-			android:layout_height="wrap_content" android:saveEnabled="true"
-			android:prompt="@string/image_size_prompt" android:entries="@array/image_sizes">
-		</Spinner>
-	</LinearLayout>
-
-	<LinearLayout android:id="@+id/LinearLayout01"
-		android:layout_width="wrap_content" android:layout_height="wrap_content"
-		android:gravity="center_vertical">
-		<TextView android:layout_width="wrap_content"
-			android:layout_height="wrap_content" android:text="@string/camera_mode_prompt" />
-		<Spinner android:id="@+id/camera_mode" android:layout_width="fill_parent"
-			android:layout_height="wrap_content" android:saveEnabled="true"
-			android:prompt="@string/camera_mode_prompt" android:entries="@array/camera_mode">
-		</Spinner>
-	</LinearLayout>
-
-		<LinearLayout android:id="@+id/LinearLayout01"
-		android:layout_width="wrap_content" android:layout_height="wrap_content"
-		android:gravity="center_vertical">
-		<TextView android:layout_width="wrap_content"
-			android:layout_height="wrap_content" android:text="@string/whitebalance_prompt" />
-		<Spinner android:id="@+id/whitebalance" android:layout_width="fill_parent"
-			android:layout_height="wrap_content" android:saveEnabled="true"
-			android:prompt="@string/whitebalance_prompt" android:entries="@array/whitebalance">
-		</Spinner>
-</LinearLayout>
-
-
-</LinearLayout>
diff --git a/android/android-opencv/res/layout/chesssizer.xml b/android/android-opencv/res/layout/chesssizer.xml
deleted file mode 100644
index b93bc0bdea..0000000000
--- a/android/android-opencv/res/layout/chesssizer.xml
+++ /dev/null
@@ -1,40 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout
-  xmlns:android="http://schemas.android.com/apk/res/android"
-  android:layout_width="fill_parent"
-  android:layout_height="fill_parent"
-  android:orientation="vertical"
-  android:gravity="center_vertical|center_horizontal">
-   <TextView android:text="@string/patterntext"  android:autoLink="web" android:layout_width="wrap_content" 
- android:layout_height="wrap_content" android:padding="20dip"/>
-  <LinearLayout android:id="@+id/LinearLayout01"
- android:layout_width="wrap_content" 
- android:layout_height="wrap_content"
- android:gravity="center_vertical">
- <TextView android:layout_width="wrap_content"
-  android:layout_height="wrap_content"
-   android:text="Corners in width direction:"/>
- <Spinner android:id="@+id/rows" 
-  android:layout_width="fill_parent"
-        android:layout_height="wrap_content"
-         android:saveEnabled="true"
-           android:prompt="@string/chesspromptx"
-android:entries="@array/chesssizes">
-</Spinner>
- </LinearLayout>
- 
- <LinearLayout android:id="@+id/LinearLayout01"
- android:layout_width="wrap_content" android:layout_height="wrap_content"
- android:gravity="center_vertical">
- <TextView android:layout_width="wrap_content"
- android:layout_height="wrap_content" android:text="Corners in height direction:"/>
- <Spinner android:id="@+id/cols" 
-  android:layout_width="fill_parent"
-        android:layout_height="wrap_content"
-        android:saveEnabled="true"
-        android:prompt="@string/chessprompty"
-android:entries="@array/chesssizes">
-</Spinner>
-</LinearLayout>
-
-</LinearLayout>
diff --git a/android/android-opencv/res/values/attrs.xml b/android/android-opencv/res/values/attrs.xml
deleted file mode 100644
index 89727ff51b..0000000000
--- a/android/android-opencv/res/values/attrs.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-
-<declare-styleable name="CameraParams">
-
-<attr name="preview_width" format="integer"/>
-<attr name="preview_height" format="integer"/>
-
-</declare-styleable>
-
-</resources>
\ No newline at end of file
diff --git a/android/android-opencv/res/values/chessnumbers.xml b/android/android-opencv/res/values/chessnumbers.xml
deleted file mode 100644
index c0b37fa9b5..0000000000
--- a/android/android-opencv/res/values/chessnumbers.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<string-array name="chesssizes">
-<item>2</item>
-<item>3</item>
-<item>4</item>
-<item>5</item>
-<item>6</item>
-<item>7</item>
-<item>8</item>
-<item>9</item>
-<item>10</item>
-<item>11</item>
-<item>12</item>
-<item>13</item>
-</string-array>
-<string name="chesspromptx">
-Choose the width:</string>
-<string name="chessprompty">
-Choose the height:</string>
-</resources>
diff --git a/android/android-opencv/res/values/settingnumbers.xml b/android/android-opencv/res/values/settingnumbers.xml
deleted file mode 100644
index 54771c1e53..0000000000
--- a/android/android-opencv/res/values/settingnumbers.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<string-array name="image_sizes">
-<item>320x240</item>
-<item>400x300</item>
-<item>640x480</item>
-<item>800x600</item>
-<item>1000x800</item>
-</string-array>
-<string-array name="camera_mode">
-<item>color</item>
-<item>BW</item>
-</string-array>
-<string name="image_size_prompt">
-Image Size:\n(may not be exact)
-</string>
-<string name="camera_mode_prompt">
-Camera Mode:
-</string>
-
-<string-array name="whitebalance">
-<item>auto</item>
-<item>incandescent</item>
-<item>fluorescent</item>
-<item>daylight</item>
-<item>cloudy-daylight</item>
-</string-array>
-<string name="whitebalance_prompt">
-Whitebalance:
-</string>
-</resources>
\ No newline at end of file
diff --git a/android/android-opencv/res/values/strings.xml b/android/android-opencv/res/values/strings.xml
deleted file mode 100644
index 541de3682b..0000000000
--- a/android/android-opencv/res/values/strings.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="app_name">Calibration</string>
-	<string name="patternsize">Pattern Size</string>
-	<string name="patterntext">Please choose the width and height (number of inside corners) of the checker
-	board pattern you will be using for calibration. Default is 6 by 8 corners. You may find a checkerboard pattern at
-	http://opencv.willowgarage.com/pattern</string>
-	
-	<string name="patternlink">http://opencv.willowgarage.com/pattern</string>
-	<string name="camera_settings_label">Camera Settings</string>
-	<string name="settings_text">Change the camera settings. Be aware that BW is much faster for previewing, than color. Also, if you change the image size, you should
-	rerun calibration.  Default values: BW and 640x480 are a good start.</string>
-	
-	<string name="calibration_service_started">Calibration calculations have started...</string>
-	<string name="calibration_service_stopped">Calibration calculations has stopped.</string>
-	<string name="calibration_service_finished">Calibration finished, you camera is calibrated.</string>
-	<string name="calibration_service_label">Calibration</string>
-	<string name="calibration_not_enough">Please capture atleast 10 images of the pattern!</string>	
-	
-</resources>
diff --git a/android/android-opencv/src/com/opencv/OpenCV.java b/android/android-opencv/src/com/opencv/OpenCV.java
deleted file mode 100644
index 0fced8026f..0000000000
--- a/android/android-opencv/src/com/opencv/OpenCV.java
+++ /dev/null
@@ -1,157 +0,0 @@
-package com.opencv;
-
-import java.util.LinkedList;
-
-import android.app.Activity;
-import android.content.pm.ActivityInfo;
-import android.os.Bundle;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.Window;
-import android.view.WindowManager;
-import android.view.ViewGroup.LayoutParams;
-import android.widget.FrameLayout;
-import android.widget.LinearLayout;
-
-import com.opencv.camera.NativePreviewer;
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.opengl.GL2CameraViewer;
-
-public class OpenCV extends Activity {
-	private NativePreviewer mPreview;
-
-	private GL2CameraViewer glview;
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see android.app.Activity#onKeyUp(int, android.view.KeyEvent)
-	 */
-	@Override
-	public boolean onKeyUp(int keyCode, KeyEvent event) {
-
-		return super.onKeyUp(keyCode, event);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see android.app.Activity#onKeyLongPress(int, android.view.KeyEvent)
-	 */
-	@Override
-	public boolean onKeyLongPress(int keyCode, KeyEvent event) {
-
-		return super.onKeyLongPress(keyCode, event);
-	}
-
-	/**
-	 * Avoid that the screen get's turned off by the system.
-	 */
-	public void disableScreenTurnOff() {
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
-				WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-	}
-
-	/**
-	 * Set's the orientation to landscape, as this is needed by AndAR.
-	 */
-	public void setOrientation() {
-		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-	}
-
-	/**
-	 * Maximize the application.
-	 */
-	public void setFullscreen() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-				WindowManager.LayoutParams.FLAG_FULLSCREEN);
-	}
-
-	public void setNoTitle() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-	}
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		// menu.add("Sample");
-		return true;
-	}
-
-	@Override
-	public boolean onOptionsItemSelected(MenuItem item) {
-		// if(item.getTitle().equals("Sample")){
-		// //do stuff...
-		// }
-
-		return true;
-
-	}
-
-	@Override
-	public void onOptionsMenuClosed(Menu menu) {
-		// TODO Auto-generated method stub
-		super.onOptionsMenuClosed(menu);
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-
-		setFullscreen();
-		disableScreenTurnOff();
-
-		FrameLayout frame = new FrameLayout(getApplication());
-
-		// Create our Preview view and set it as the content of our activity.
-		mPreview = new NativePreviewer(getApplication(), 640, 480);
-
-		LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT,
-				LayoutParams.WRAP_CONTENT);
-		params.height = getWindowManager().getDefaultDisplay().getHeight();
-		params.width = (int) (params.height * 4.0 / 2.88);
-
-		LinearLayout vidlay = new LinearLayout(getApplication());
-
-		vidlay.setGravity(Gravity.CENTER);
-		vidlay.addView(mPreview, params);
-		frame.addView(vidlay);
-		
-		// make the glview overlay ontop of video preview
-		mPreview.setZOrderMediaOverlay(false);
-		
-		glview = new GL2CameraViewer(getApplication(), false, 0, 0);
-		glview.setZOrderMediaOverlay(true);
-		glview.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,
-				LayoutParams.FILL_PARENT));
-		frame.addView(glview);
-
-		setContentView(frame);
-	}
-
-	@Override
-	protected void onPause() {
-		super.onPause();
-		
-		mPreview.onPause();
-		
-		glview.onPause();
-		
-
-	}
-
-	@Override
-	protected void onResume() {
-		super.onResume();
-		glview.onResume();
-		LinkedList<NativeProcessor.PoolCallback> callbackstack = new LinkedList<PoolCallback>();
-		callbackstack.add(glview.getDrawCallback());
-		mPreview.addCallbackStack(callbackstack);
-		mPreview.onResume();
-
-	}
-
-}
diff --git a/android/android-opencv/src/com/opencv/calibration/CalibrationViewer.java b/android/android-opencv/src/com/opencv/calibration/CalibrationViewer.java
deleted file mode 100644
index 2ae6b7871d..0000000000
--- a/android/android-opencv/src/com/opencv/calibration/CalibrationViewer.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package com.opencv.calibration;
-
-import java.io.BufferedReader;
-import java.io.FileNotFoundException;
-import java.io.FileReader;
-import java.io.IOException;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.text.method.ScrollingMovementMethod;
-import android.util.Log;
-import android.widget.TextView;
-
-import com.opencv.R;
-
-public class CalibrationViewer extends Activity {
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		// TODO Auto-generated method stub
-		super.onCreate(savedInstanceState);
-		setContentView(R.layout.calibrationviewer);
-
-		Bundle extras = getIntent().getExtras();
-		String filename = extras.getString("calibfile");
-		if (filename != null) {
-			TextView text = (TextView) findViewById(R.id.calibtext);
-			text.setMovementMethod(new ScrollingMovementMethod());
-			try {
-				BufferedReader reader = new BufferedReader(new FileReader(
-						filename));
-				while (reader.ready()) {
-					text.append(reader.readLine() +"\n");
-				}
-
-			} catch (FileNotFoundException e) {
-				Log.e("opencv", "could not open calibration file at:"
-						+ filename);
-			} catch (IOException e) {
-				Log.e("opencv", "error reading file: "
-						+ filename);
-			}
-		}
-
-	}
-
-}
diff --git a/android/android-opencv/src/com/opencv/calibration/Calibrator.java b/android/android-opencv/src/com/opencv/calibration/Calibrator.java
deleted file mode 100644
index 699a196e83..0000000000
--- a/android/android-opencv/src/com/opencv/calibration/Calibrator.java
+++ /dev/null
@@ -1,124 +0,0 @@
-package com.opencv.calibration;
-
-
-import java.io.File;
-import java.io.IOException;
-import java.util.concurrent.locks.ReentrantLock;
-
-import android.os.AsyncTask;
-
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.jni.Calibration;
-import com.opencv.jni.Size;
-import com.opencv.jni.image_pool;
-
-
-
-public class Calibrator implements PoolCallback {
-	private Calibration calibration;
-
-	static public interface CalibrationCallback{
-		public void onFoundChessboard(Calibrator calibrator);
-		public void onDoneCalibration(Calibrator calibration, File calibfile);
-		public void onFailedChessboard(Calibrator calibrator);
-	}
-	private CalibrationCallback callback;
-	public Calibrator(CalibrationCallback callback) {
-		calibration = new Calibration();
-		this.callback = callback;
-	}
-
-	public void resetCalibration(){
-		calibration.resetChess();
-	}
-
-	public void setPatternSize(Size size){
-		Size csize = calibration.getPatternsize();
-		if(size.getWidth() == csize.getWidth()&&
-				   size.getHeight() == csize.getHeight())
-					return;
-		calibration.setPatternsize(size);	
-		resetCalibration();
-	}
-	public void setPatternSize(int width, int height){
-		Size patternsize = new Size(width,height);
-		setPatternSize(patternsize);
-	}
-	
-	private boolean capture_chess;
-
-	ReentrantLock lock = new ReentrantLock();
-	public void calibrate(File calibration_file) throws IOException{
-		if(getNumberPatternsDetected() < 3){
-			return;
-		}
-		CalibrationTask calibtask = new CalibrationTask(calibration_file);
-		calibtask.execute((Object[])null);
-	}
-
-	public void queueChessCapture(){
-		capture_chess = true;
-	}
-	
-private class CalibrationTask extends AsyncTask<Object, Object, Object> {
-		File calibfile;
-	
-		public CalibrationTask(File calib) throws IOException{
-			super();
-			calibfile = calib;
-			calibfile.createNewFile();
-		}
-	
-		@Override
-		protected Object doInBackground(Object... params) {
-			lock.lock();
-			try{
-				calibration.calibrate(calibfile.getAbsolutePath());
-			}
-			finally{
-				lock.unlock();
-			}
-			return null;
-		
-		}
-
-		@Override
-		protected void onPostExecute(Object result) {			
-			callback.onDoneCalibration(Calibrator.this, calibfile);
-		}
-
-	}
-	
-
-	//@Override
-	public void process(int idx, image_pool pool, long timestamp,
-			NativeProcessor nativeProcessor) {
-		if(lock.tryLock()){
-			try{
-				if(capture_chess){
-					if(calibration.detectAndDrawChessboard(idx, pool)){
-						callback.onFoundChessboard(this);
-						
-					}else
-						callback.onFailedChessboard(this);
-					capture_chess = false;
-				}
-			}finally{
-				lock.unlock();
-			}
-		}
-	}
-
-
-	public int getNumberPatternsDetected(){
-		return calibration.getNumberDetectedChessboards();
-	}
-
-	public void setCallback(CalibrationCallback callback) {
-		this.callback = callback;
-		
-	}
-
-
-}
diff --git a/android/android-opencv/src/com/opencv/calibration/ChessBoardChooser.java b/android/android-opencv/src/com/opencv/calibration/ChessBoardChooser.java
deleted file mode 100644
index 461a37d9be..0000000000
--- a/android/android-opencv/src/com/opencv/calibration/ChessBoardChooser.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package com.opencv.calibration;
-
-import com.opencv.R;
-import com.opencv.jni.Size;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.SharedPreferences;
-import android.content.SharedPreferences.Editor;
-import android.os.Bundle;
-import android.view.View;
-import android.widget.AdapterView;
-import android.widget.AdapterView.OnItemSelectedListener;
-import android.widget.Spinner;
-
-public class ChessBoardChooser extends Activity {
-	public static final String CHESS_SIZE = "chess_size";
-	public static final int DEFAULT_WIDTH = 6;
-	public static final int DEFAULT_HEIGHT = 8;
-	public static final int LOWEST = 2;
-
-	class DimChooser implements OnItemSelectedListener {
-		private String dim;
-
-		public DimChooser(String dim) {
-			this.dim = dim;
-		}
-
-		@Override
-		public void onItemSelected(AdapterView<?> arg0, View arg1, int pos,
-				long arg3) {
-			SharedPreferences settings = getSharedPreferences(CHESS_SIZE, 0);
-			Editor editor = settings.edit();
-			editor.putInt(dim, pos + LOWEST);
-			editor.commit();
-		}
-
-		@Override
-		public void onNothingSelected(AdapterView<?> arg0) {
-		}
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		// TODO Auto-generated method stub
-		super.onCreate(savedInstanceState);
-		setContentView(R.layout.chesssizer);
-		// Restore preferences
-		SharedPreferences settings = getSharedPreferences(CHESS_SIZE, 0);
-		int width = settings.getInt("width", 6);
-
-		int height = settings.getInt("height", 8);
-
-		Spinner wspin, hspin;
-		wspin = (Spinner) findViewById(R.id.rows);
-		hspin = (Spinner) findViewById(R.id.cols);
-
-		wspin.setSelection(width - LOWEST);
-		hspin.setSelection(height - LOWEST);
-
-		wspin.setOnItemSelectedListener(new DimChooser("width"));
-		hspin.setOnItemSelectedListener(new DimChooser("height"));
-
-	}
-
-	public static Size getPatternSize(Context ctx) {
-		SharedPreferences settings = ctx.getSharedPreferences(CHESS_SIZE, 0);
-		int width = settings.getInt("width", 6);
-
-		int height = settings.getInt("height", 8);
-
-		return new Size(width, height);
-	}
-
-}
diff --git a/android/android-opencv/src/com/opencv/calibration/services/CalibrationService.java b/android/android-opencv/src/com/opencv/calibration/services/CalibrationService.java
deleted file mode 100644
index 754e2f1ee3..0000000000
--- a/android/android-opencv/src/com/opencv/calibration/services/CalibrationService.java
+++ /dev/null
@@ -1,166 +0,0 @@
-package com.opencv.calibration.services;
-
-import java.io.File;
-import java.io.IOException;
-
-import android.app.Notification;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.app.Service;
-import android.content.Intent;
-import android.os.Binder;
-import android.os.IBinder;
-import android.util.Log;
-import android.widget.Toast;
-
-
-import com.opencv.R;
-import com.opencv.calibration.CalibrationViewer;
-import com.opencv.calibration.Calibrator;
-import com.opencv.calibration.Calibrator.CalibrationCallback;
-
-
-public class CalibrationService extends Service implements CalibrationCallback {
-
-	Class<?> activity;
-	int icon;
-	File calibration_file;
-	public void startCalibrating(Class<?> activitycaller,int icon_id, Calibrator calibrator, File calibration_file)
-			throws IOException {
-		activity = activitycaller;
-		icon = icon_id;
-		// Display a notification about us starting. We put an icon in the
-		// status bar.
-		showNotification();
-		this.calibration_file = calibration_file;
-		calibrator.setCallback(this);
-		calibrator.calibrate(calibration_file);
-		
-		
-	}
-
-	private NotificationManager mNM;
-
-	/**
-	 * Class for clients to access. Because we know this service always runs in
-	 * the same process as its clients, we don't need to deal with IPC.
-	 */
-	public class CalibrationServiceBinder extends Binder {
-		public CalibrationService getService() {
-			return CalibrationService.this;
-		}
-	}
-
-	@Override
-	public int onStartCommand(Intent intent, int flags, int startId) {
-		Log.i("LocalService", "Received start id " + startId + ": " + intent);
-		// We want this service to continue running until it is explicitly
-		// stopped, so return sticky.
-		return START_NOT_STICKY;
-	}
-
-	@Override
-	public void onCreate() {
-		mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
-
-		
-	}
-
-	@Override
-	public void onDestroy() {
-		// Cancel the persistent notification.
-		// mNM.cancel(R.string.calibration_service_started);
-
-		// Tell the user we stopped.
-		Toast.makeText(this, R.string.calibration_service_finished,
-				Toast.LENGTH_SHORT).show();
-	}
-
-	private final IBinder mBinder = new CalibrationServiceBinder();
-
-	@Override
-	public IBinder onBind(Intent intent) {
-		return mBinder;
-	}
-
-	/**
-	 * Show a notification while this service is running.
-	 */
-	private void showNotification() {
-		// In this sample, we'll use the same text for the ticker and the
-		// expanded notification
-		CharSequence text = getText(R.string.calibration_service_started);
-
-		// Set the icon, scrolling text and timestamp
-		Notification notification = new Notification(icon, text,
-				System.currentTimeMillis());
-
-		// The PendingIntent to launch our activity if the user selects this
-		// notification
-		PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
-				new Intent(this, activity), 0);
-
-		// Set the info for the views that show in the notification panel.
-		notification.setLatestEventInfo(this,
-				getText(R.string.calibration_service_label), text,
-				contentIntent);
-
-		notification.defaults |= Notification.DEFAULT_SOUND;
-		// Send the notification.
-		// We use a layout id because it is a unique number. We use it later to
-		// cancel.
-		mNM.notify(R.string.calibration_service_started, notification);
-	}
-
-	/**
-	 * Show a notification while this service is running.
-	 */
-	private void doneNotification() {
-		// In this sample, we'll use the same text for the ticker and the
-		// expanded notification
-		CharSequence text = getText(R.string.calibration_service_finished);
-
-		// Set the icon, scrolling text and timestamp
-		Notification notification = new Notification(icon, text,
-				System.currentTimeMillis());
-
-		Intent intent = new Intent(this,CalibrationViewer.class);
-		intent.putExtra("calibfile", calibration_file.getAbsolutePath());
-		// The PendingIntent to launch our activity if the user selects this
-		// notification
-		PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
-				intent, 0);
-		
-
-		// Set the info for the views that show in the notification panel.
-		notification.setLatestEventInfo(this,
-				getText(R.string.calibration_service_label), text,
-				contentIntent);
-		
-
-		notification.defaults |= Notification.DEFAULT_SOUND;
-		// Send the notification.
-		// We use a layout id because it is a unique number. We use it later to
-		// cancel.
-		mNM.notify(R.string.calibration_service_started, notification);
-	}
-
-	@Override
-	public void onFoundChessboard(Calibrator calibrator) {
-		// TODO Auto-generated method stub
-
-	}
-
-	@Override
-	public void onDoneCalibration(Calibrator calibration, File calibfile) {
-		doneNotification();
-		stopSelf();
-	}
-
-	@Override
-	public void onFailedChessboard(Calibrator calibrator) {
-		// TODO Auto-generated method stub
-
-	}
-
-}
diff --git a/android/android-opencv/src/com/opencv/camera/CameraActivity.java b/android/android-opencv/src/com/opencv/camera/CameraActivity.java
deleted file mode 100644
index ddb35a5649..0000000000
--- a/android/android-opencv/src/com/opencv/camera/CameraActivity.java
+++ /dev/null
@@ -1,128 +0,0 @@
-package com.opencv.camera;
-
-import java.util.LinkedList;
-
-import android.app.Activity;
-import android.content.pm.ActivityInfo;
-import android.os.Bundle;
-import android.view.KeyEvent;
-import android.view.MotionEvent;
-import android.view.Window;
-import android.view.WindowManager;
-import android.widget.LinearLayout;
-
-import com.opencv.camera.CameraButtonsHandler.CaptureListener;
-import com.opencv.opengl.GL2CameraViewer;
-
-public abstract class CameraActivity extends Activity implements CaptureListener {
-
-	/** Called when the activity is first created. */
-	@Override
-	public void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		setFullscreen();
-		setOrientation();
-		disableScreenTurnOff();
-		setContentView(com.opencv.R.layout.camera);
-		cameraButtonHandler = new CameraButtonsHandler(this,this);
-		mPreview = (NativePreviewer) findViewById(com.opencv.R.id.nativepreviewer);
-		LinearLayout glview_layout = (LinearLayout) findViewById(com.opencv.R.id.glview_layout);
-		glview = new GL2CameraViewer(getApplication(), true, 0, 0);
-		glview_layout.addView(glview);
-	}
-
-	/**
-	 * Handle the capture button as follows...
-	 */
-	@Override
-	public boolean onKeyUp(int keyCode, KeyEvent event) {
-
-		switch (keyCode) {
-		case KeyEvent.KEYCODE_CAMERA:
-		case KeyEvent.KEYCODE_SPACE:
-		case KeyEvent.KEYCODE_DPAD_CENTER:
-			cameraButtonHandler.setIsCapture(true);
-			return true;
-
-		default:
-			return super.onKeyUp(keyCode, event);
-		}
-
-	}
-
-	/**
-	 * Handle the capture button as follows... On some phones there is no
-	 * capture button, only trackball
-	 */
-	@Override
-	public boolean onTrackballEvent(MotionEvent event) {
-		if (event.getAction() == MotionEvent.ACTION_UP) {
-			cameraButtonHandler.setIsCapture(true);
-			return true;
-		}
-		return super.onTrackballEvent(event);
-	}
-
-	/**
-	 * Avoid that the screen get's turned off by the system.
-	 */
-	public void disableScreenTurnOff() {
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
-				WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-	}
-
-	/**
-	 * Set's the orientation to landscape, as this is needed by AndAR.
-	 */
-	public void setOrientation() {
-		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-	}
-
-	/**
-	 * Maximize the application.
-	 */
-	public void setFullscreen() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-				WindowManager.LayoutParams.FLAG_FULLSCREEN);
-	}
-
-	@Override
-	protected void onPause() {
-		super.onPause();
-		mPreview.onPause();
-		glview.onPause();
-	}
-
-	@Override
-	protected void onResume() {
-		super.onResume();
-		mPreview.setParamsFromPrefs(getApplicationContext());
-		glview.onResume();
-		mPreview.onResume();
-		setCallbackStack();
-	}
-
-	protected void setCallbackStack() {
-		LinkedList<NativeProcessor.PoolCallback> callbackstack = getCallBackStack();
-		if (callbackstack == null){
-			callbackstack = new LinkedList<NativeProcessor.PoolCallback>();
-			callbackstack.add(glview.getDrawCallback());
-		}
-		mPreview.addCallbackStack(callbackstack);
-	}
-
-	/**
-	 * Overide this and provide your processors to the camera
-	 * 
-	 * @return null for default drawing
-	 */
-	protected abstract LinkedList<NativeProcessor.PoolCallback> getCallBackStack();
-	public void onCapture(){
-		
-	}
-
-	protected NativePreviewer mPreview;
-	protected GL2CameraViewer glview;
-	protected CameraButtonsHandler cameraButtonHandler;
-}
diff --git a/android/android-opencv/src/com/opencv/camera/CameraButtonsHandler.java b/android/android-opencv/src/com/opencv/camera/CameraButtonsHandler.java
deleted file mode 100644
index bbf5c2d7b3..0000000000
--- a/android/android-opencv/src/com/opencv/camera/CameraButtonsHandler.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package com.opencv.camera;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.Intent;
-import android.view.View;
-import android.view.View.OnClickListener;
-import android.widget.ImageButton;
-
-public class CameraButtonsHandler {
-	/** Constructs a buttons handler, will register with the capture button
-	 * and the camera settings button. 
-	 * @param a The activity that has inflated the com.opencv.R.layout.camera
-	 * as its layout.
-	 */
-	public CameraButtonsHandler(Activity a, CaptureListener l) {
-		ImageButton capture = (ImageButton) a
-				.findViewById(com.opencv.R.id.button_capture);
-		ImageButton settings = (ImageButton) a
-				.findViewById(com.opencv.R.id.button_camera_settings);
-		capture.setOnClickListener(capture_listener);
-		settings.setOnClickListener(settings_listener);
-		captureListener = l;
-		ctx = a;
-	}
-	
-	public CameraButtonsHandler(Activity a) {
-		ImageButton capture = (ImageButton) a
-				.findViewById(com.opencv.R.id.button_capture);
-		ImageButton settings = (ImageButton) a
-				.findViewById(com.opencv.R.id.button_camera_settings);
-		capture.setOnClickListener(capture_listener);
-		settings.setOnClickListener(settings_listener);
-		ctx = a;
-	}
-	
-	
-	/** Check if the capture button has been pressed
-	 * @return true if the capture button has been pressed
-	 */
-	synchronized public boolean isCapture(){
-		return capture_flag;
-	}
-	
-	/** Reset the capture flag 
-	 */
-	synchronized public void resetIsCapture(){
-		capture_flag = false;
-	}
-	
-	/** Manually set the flag - call this on any event that should trigger
-	 * a capture
-	 * @param isCapture true if a capture should take place
-	 */
-	synchronized public void setIsCapture(boolean isCapture){
-		capture_flag = isCapture;
-		if(capture_flag && captureListener != null){
-			captureListener.onCapture();
-		}
-	}
-	
-	private OnClickListener capture_listener = new View.OnClickListener() {
-		@Override
-		public void onClick(View v) {
-			setIsCapture(true);
-		}
-	};
-	private OnClickListener settings_listener = new View.OnClickListener() {
-		@Override
-		public void onClick(View v) {
-			Intent configurer = new Intent(ctx,
-					CameraConfig.class);
-			ctx.startActivity(configurer);
-		}
-	};
-
-	interface CaptureListener{
-		public void onCapture();
-	}
-	private CaptureListener captureListener;
-	private Context ctx;		
-	private boolean capture_flag = false;
-}
diff --git a/android/android-opencv/src/com/opencv/camera/CameraConfig.java b/android/android-opencv/src/com/opencv/camera/CameraConfig.java
deleted file mode 100644
index fcedd1b28b..0000000000
--- a/android/android-opencv/src/com/opencv/camera/CameraConfig.java
+++ /dev/null
@@ -1,214 +0,0 @@
-package com.opencv.camera;
-
-import com.opencv.R;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.SharedPreferences;
-import android.content.SharedPreferences.Editor;
-import android.os.Bundle;
-import android.view.View;
-import android.widget.AdapterView;
-import android.widget.AdapterView.OnItemSelectedListener;
-import android.widget.Spinner;
-
-public class CameraConfig extends Activity {
-	public static final String CAMERA_SETTINGS = "CAMERA_SETTINGS";
-	public static final String CAMERA_MODE = "camera_mode";
-	public static final String IMAGE_WIDTH = "IMAGE_WIDTH";
-	public static final String IMAGE_HEIGHT = "IMAGE_HEIGHT";
-	public static final int CAMERA_MODE_BW = 0;
-	public static final int CAMERA_MODE_COLOR = 1;
-	private static final String WHITEBALANCE = "WHITEBALANCE";
-
-	public static int readCameraMode(Context ctx) {
-		// Restore preferences
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		int mode = settings.getInt(CAMERA_MODE, CAMERA_MODE_BW);
-		return mode;
-	}
-	
-	public static String readWhitebalace(Context ctx) {
-		// Restore preferences
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		return settings.getString(WHITEBALANCE, "auto");
-	}
-
-	static public void setCameraMode(Context context, String mode) {
-		int m = 0;
-		if (mode.equals("BW")) {
-			m = CAMERA_MODE_BW;
-		} else if (mode.equals("color"))
-			m = CAMERA_MODE_COLOR;
-		setCameraMode(context, m);
-	}
-
-	private static String sizeToString(int[] size) {
-		return size[0] + "x" + size[1];
-	}
-
-	private static void parseStrToSize(String ssize, int[] size) {
-		String sz[] = ssize.split("x");
-		size[0] = Integer.valueOf(sz[0]);
-		size[1] = Integer.valueOf(sz[1]);
-	}
-
-	public static void readImageSize(Context ctx, int[] size) {
-		// Restore preferences
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		size[0] = settings.getInt(IMAGE_WIDTH, 640);
-		size[1] = settings.getInt(IMAGE_HEIGHT, 480);
-
-	}
-
-	public static void setCameraMode(Context ctx, int mode) {
-		// Restore preferences
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		Editor editor = settings.edit();
-		editor.putInt(CAMERA_MODE, mode);
-		editor.commit();
-	}
-
-	public static void setImageSize(Context ctx, String strsize) {
-		int size[] = { 0, 0 };
-		parseStrToSize(strsize, size);
-		setImageSize(ctx, size[0], size[1]);
-	}
-
-	public static void setImageSize(Context ctx, int width, int height) {
-		// Restore preferences
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		Editor editor = settings.edit();
-		editor.putInt(IMAGE_WIDTH, width);
-		editor.putInt(IMAGE_HEIGHT, height);
-		editor.commit();
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		// TODO Auto-generated method stub
-		super.onCreate(savedInstanceState);
-		setContentView(R.layout.camerasettings);
-		int mode = readCameraMode(this);
-		int size[] = { 0, 0 };
-		readImageSize(this, size);
-
-		final Spinner size_spinner;
-		final Spinner mode_spinner;
-		final Spinner whitebalance_spinner;
-		size_spinner = (Spinner) findViewById(R.id.image_size);
-		mode_spinner = (Spinner) findViewById(R.id.camera_mode);
-		whitebalance_spinner = (Spinner) findViewById(R.id.whitebalance);
-
-		String strsize = sizeToString(size);
-		String strmode = modeToString(mode);
-		String wbmode = readWhitebalace(getApplicationContext());
-
-		String sizes[] = getResources().getStringArray(R.array.image_sizes);
-
-		int i = 1;
-		for (String x : sizes) {
-			if (x.equals(strsize))
-				break;
-			i++;
-		}
-		if(i <= sizes.length)
-			size_spinner.setSelection(i-1);
-
-		i = 1;
-		String modes[] =  getResources().getStringArray(R.array.camera_mode);
-		for (String x :modes) {
-			if (x.equals(strmode))
-				break;
-			i++;
-		}
-		if(i <= modes.length)
-			mode_spinner.setSelection(i-1);
-		
-		i = 1;
-		String wbmodes[] =  getResources().getStringArray(R.array.whitebalance);
-		for (String x :wbmodes) {
-			if (x.equals(wbmode))
-				break;
-			i++;
-		}
-		if(i <= wbmodes.length)
-			whitebalance_spinner.setSelection(i-1);
-
-		size_spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
-
-			@Override
-			public void onItemSelected(AdapterView<?> arg0, View spinner,
-					int position, long arg3) {
-				Object o = size_spinner.getItemAtPosition(position);
-				if (o != null)
-					setImageSize(spinner.getContext(), (String) o);
-			}
-
-			@Override
-			public void onNothingSelected(AdapterView<?> arg0) {
-
-			}
-		});
-		mode_spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
-
-			@Override
-			public void onItemSelected(AdapterView<?> arg0, View spinner,
-					int position, long arg3) {
-				Object o = mode_spinner.getItemAtPosition(position);
-				if (o != null)
-					setCameraMode(spinner.getContext(), (String) o);
-
-			}
-
-			@Override
-			public void onNothingSelected(AdapterView<?> arg0) {
-
-			}
-		});
-
-		whitebalance_spinner.setOnItemSelectedListener(new OnItemSelectedListener() {
-
-			@Override
-			public void onItemSelected(AdapterView<?> arg0, View spinner,
-					int position, long arg3) {
-				Object o = whitebalance_spinner.getItemAtPosition(position);
-				if (o != null)
-					setWhitebalance(spinner.getContext(), (String) o);
-
-			}
-
-
-			@Override
-			public void onNothingSelected(AdapterView<?> arg0) {
-
-			}
-		});
-
-	}
-
-	public static void setWhitebalance(Context ctx, String o) {
-		SharedPreferences settings = ctx.getSharedPreferences(CAMERA_SETTINGS,
-				0);
-		Editor editor = settings.edit();
-		editor.putString(WHITEBALANCE, o);
-		editor.commit();
-		
-	}
-
-	private String modeToString(int mode) {
-		switch (mode) {
-		case CAMERA_MODE_BW:
-			return "BW";
-		case CAMERA_MODE_COLOR:
-			return "color";
-		default:
-			return "";
-		}
-	}
-}
diff --git a/android/android-opencv/src/com/opencv/camera/NativePreviewer.java b/android/android-opencv/src/com/opencv/camera/NativePreviewer.java
deleted file mode 100644
index 1accee723e..0000000000
--- a/android/android-opencv/src/com/opencv/camera/NativePreviewer.java
+++ /dev/null
@@ -1,476 +0,0 @@
-package com.opencv.camera;
-
-import java.io.IOException;
-import java.lang.reflect.Method;
-import java.util.Date;
-import java.util.LinkedList;
-import java.util.List;
-
-import android.content.Context;
-import android.graphics.PixelFormat;
-import android.hardware.Camera;
-import android.hardware.Camera.PreviewCallback;
-import android.hardware.Camera.Size;
-import android.os.Handler;
-import android.util.AttributeSet;
-import android.util.Log;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-
-import com.opencv.camera.NativeProcessor.NativeProcessorCallback;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-
-public class NativePreviewer extends SurfaceView implements
-		SurfaceHolder.Callback, Camera.PreviewCallback, NativeProcessorCallback {
-
-	private String whitebalance_mode = "auto";
-
-	/**
-	 * Constructor useful for defining a NativePreviewer in android layout xml
-	 * 
-	 * @param context
-	 * @param attributes 
-	 */
-	public NativePreviewer(Context context, AttributeSet attributes) {
-		super(context, attributes);
-		listAllCameraMethods();
-		// Install a SurfaceHolder.Callback so we get notified when the
-		// underlying surface is created and destroyed.
-		mHolder = getHolder();
-		mHolder.addCallback(this);
-		mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
-
-		/*
-		 * TODO get this working! Can't figure out how to define these in xml
-		 */
-		preview_width = attributes.getAttributeIntValue("opencv",
-				"preview_width", 600);
-		preview_height = attributes.getAttributeIntValue("opencv",
-				"preview_height", 600);
-		
-		Log.d("NativePreviewer", "Trying to use preview size of "
-				+ preview_width + " " + preview_height);
-
-		processor = new NativeProcessor();
-
-		setZOrderMediaOverlay(false);
-	}
-
-	/**
-	 * 
-	 * @param context
-	 * @param preview_width
-	 *            the desired camera preview width - will attempt to get as
-	 *            close to this as possible
-	 * @param preview_height
-	 *            the desired camera preview height
-	 */
-	public NativePreviewer(Context context, int preview_width,
-			int preview_height) {
-		super(context);
-
-		listAllCameraMethods();
-		// Install a SurfaceHolder.Callback so we get notified when the
-		// underlying surface is created and destroyed.
-		mHolder = getHolder();
-		mHolder.addCallback(this);
-		mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
-
-		this.preview_width = preview_width;
-		this.preview_height = preview_height;
-
-		processor = new NativeProcessor();
-		setZOrderMediaOverlay(false);
-
-	}
-
-	/**
-	 * Only call in the oncreate function of the instantiating activity
-	 * 
-	 * @param width
-	 *            desired width
-	 * @param height
-	 *            desired height
-	 */
-	public void setPreviewSize(int width, int height){
-		preview_width = width;
-		preview_height = height;
-		
-		Log.d("NativePreviewer", "Trying to use preview size of "
-				+ preview_width + " " + preview_height);
-
-	}
-	
-	public void setParamsFromPrefs(Context ctx){
-		int size[] ={0,0};
-		CameraConfig.readImageSize(ctx, size);
-		int mode = CameraConfig.readCameraMode(ctx);
-		setPreviewSize(size[0], size[1]);
-		setGrayscale(mode == CameraConfig.CAMERA_MODE_BW ? true : false);
-		whitebalance_mode = CameraConfig.readWhitebalace(ctx);
-	}
-
-	public void surfaceCreated(SurfaceHolder holder) {
-
-	}
-
-	public void surfaceDestroyed(SurfaceHolder holder) {
-		releaseCamera();
-	}
-
-	public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
-
-		try {
-			initCamera(mHolder);
-		} catch (InterruptedException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-			return;
-		}
-
-		// Now that the size is known, set up the camera parameters and begin
-		// the preview.
-
-		Camera.Parameters parameters = mCamera.getParameters();
-		List<Camera.Size> pvsizes = mCamera.getParameters()
-				.getSupportedPreviewSizes();
-		int best_width = 1000000;
-		int best_height = 1000000;
-		int bdist = 100000;
-		for (Size x : pvsizes) {
-			if (Math.abs(x.width - preview_width) < bdist) {
-				bdist = Math.abs(x.width - preview_width);
-				best_width = x.width;
-				best_height = x.height;
-			}
-		}
-		preview_width = best_width;
-		preview_height = best_height;
-		
-		Log.d("NativePreviewer", "Determined compatible preview size is: ("
-				+ preview_width + "," + preview_height + ")");
-
-		Log.d("NativePreviewer", "Supported params: "
-				+ mCamera.getParameters().flatten());
-
-		List<String> whiteBalanceModes = parameters.getSupportedWhiteBalance();
-		if (whiteBalanceModes != null
-		 && whiteBalanceModes.contains(whitebalance_mode) ) {
-			parameters.setWhiteBalance(whitebalance_mode);
-		}
-
-		if (parameters.get("meter-mode") != null)
-			parameters.set("meter-mode", "meter-average");
-
-		List<String> fmodes = mCamera.getParameters().getSupportedFocusModes();
-		if(fmodes != null)
-		{
-		  int idx = fmodes.indexOf(Camera.Parameters.FOCUS_MODE_INFINITY);
-		  if (idx != -1) {
-			  parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_INFINITY);
-		  } else if (fmodes.indexOf(Camera.Parameters.FOCUS_MODE_FIXED) != -1) {
-			  parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_FIXED);
-		  }
-
-		  if (fmodes.indexOf(Camera.Parameters.FOCUS_MODE_AUTO) != -1) {
-			  hasAutoFocus = true;
-		  }
-		}
-
-		List<String> scenemodes = mCamera.getParameters()
-				.getSupportedSceneModes();
-		if (scenemodes != null)
-			if (scenemodes.indexOf(Camera.Parameters.SCENE_MODE_ACTION) != -1) {
-				parameters.setSceneMode(Camera.Parameters.SCENE_MODE_ACTION);
-				Log.d("NativePreviewer", "set scenemode to action");
-			}
-
-		parameters.setPreviewSize(preview_width, preview_height);
-
-		mCamera.setParameters(parameters);
-
-		pixelinfo = new PixelFormat();
-		pixelformat = mCamera.getParameters().getPreviewFormat();
-		PixelFormat.getPixelFormatInfo(pixelformat, pixelinfo);
-
-		Size preview_size = mCamera.getParameters().getPreviewSize();
-		preview_width = preview_size.width;
-		preview_height = preview_size.height;
-		int bufSize = preview_width * preview_height * pixelinfo.bitsPerPixel
-				/ 8;
-
-		// Must call this before calling addCallbackBuffer to get all the
-		// reflection variables setup
-		initForACB();
-		initForPCWB();
-
-		// Use only one buffer, so that we don't preview too many frames and bog
-		// down system
-		byte[] buffer = new byte[bufSize];
-		addCallbackBuffer(buffer);
-		setPreviewCallbackWithBuffer();
-
-		mCamera.startPreview();
-
-	}
-
-	public void postautofocus(int delay) {
-		if (hasAutoFocus)
-			handler.postDelayed(autofocusrunner, delay);
-
-	}
-
-	/**
-	 * Demonstration of how to use onPreviewFrame. In this case I'm not
-	 * processing the data, I'm just adding the buffer back to the buffer queue
-	 * for re-use
-	 */
-	public void onPreviewFrame(byte[] data, Camera camera) {
-
-		if (start == null) {
-			start = new Date();
-		}
-
-		processor.post(data, preview_width, preview_height, pixelformat,
-				System.nanoTime(), this);
-
-		fcount++;
-		if (fcount % 100 == 0) {
-			double ms = (new Date()).getTime() - start.getTime();
-			Log.i("NativePreviewer", "fps:" + fcount / (ms / 1000.0));
-			start = new Date();
-			fcount = 0;
-		}
-
-	}
-
-	@Override
-	public void onDoneNativeProcessing(byte[] buffer) {
-		addCallbackBuffer(buffer);
-	}
-
-	public void addCallbackStack(LinkedList<PoolCallback> callbackstack) {
-		processor.addCallbackStack(callbackstack);
-	}
-
-	/**
-	 * This must be called when the activity pauses, in Activity.onPause This
-	 * has the side effect of clearing the callback stack.
-	 * 
-	 */
-	public void onPause() {
-
-		releaseCamera();
-
-		addCallbackStack(null);
-
-		processor.stop();
-
-	}
-
-	public void onResume() {
-
-		processor.start();
-
-	}
-
-	private Method mPCWB;
-
-	private void initForPCWB() {
-
-		try {
-
-			mPCWB = Class.forName("android.hardware.Camera").getMethod(
-					"setPreviewCallbackWithBuffer", PreviewCallback.class);
-
-		} catch (Exception e) {
-			Log.e("NativePreviewer",
-					"Problem setting up for setPreviewCallbackWithBuffer: "
-							+ e.toString());
-		}
-
-	}
-
-	/**
-	 * This method allows you to add a byte buffer to the queue of buffers to be
-	 * used by preview. See:
-	 * http://android.git.kernel.org/?p=platform/frameworks
-	 * /base.git;a=blob;f=core/java/android/hardware/Camera.java;hb=9d
-	 * b3d07b9620b4269ab33f78604a36327e536ce1
-	 * 
-	 * @param b
-	 *            The buffer to register. Size should be width * height *
-	 *            bitsPerPixel / 8.
-	 */
-	private void addCallbackBuffer(byte[] b) {
-
-		try {
-
-			mAcb.invoke(mCamera, b);
-		} catch (Exception e) {
-			Log.e("NativePreviewer",
-					"invoking addCallbackBuffer failed: " + e.toString());
-		}
-	}
-
-	/**
-	 * Use this method instead of setPreviewCallback if you want to use manually
-	 * allocated buffers. Assumes that "this" implements Camera.PreviewCallback
-	 */
-	private void setPreviewCallbackWithBuffer() {
-		// mCamera.setPreviewCallback(this);
-		// return;
-		try {
-
-			// If we were able to find the setPreviewCallbackWithBuffer method
-			// of Camera,
-			// we can now invoke it on our Camera instance, setting 'this' to be
-			// the
-			// callback handler
-			mPCWB.invoke(mCamera, this);
-
-			// Log.d("NativePrevier","setPreviewCallbackWithBuffer: Called method");
-
-		} catch (Exception e) {
-
-			Log.e("NativePreviewer", e.toString());
-		}
-	}
-
-	@SuppressWarnings("unused")
-	private void clearPreviewCallbackWithBuffer() {
-		// mCamera.setPreviewCallback(this);
-		// return;
-		try {
-
-			// If we were able to find the setPreviewCallbackWithBuffer method
-			// of Camera,
-			// we can now invoke it on our Camera instance, setting 'this' to be
-			// the
-			// callback handler
-			mPCWB.invoke(mCamera, (PreviewCallback) null);
-
-			// Log.d("NativePrevier","setPreviewCallbackWithBuffer: cleared");
-
-		} catch (Exception e) {
-
-			Log.e("NativePreviewer", e.toString());
-		}
-	}
-
-	/**
-	 * These variables are re-used over and over by addCallbackBuffer
-	 */
-	private Method mAcb;
-
-	private void initForACB() {
-		try {
-
-			mAcb = Class.forName("android.hardware.Camera").getMethod(
-					"addCallbackBuffer", byte[].class);
-
-		} catch (Exception e) {
-			Log.e("NativePreviewer",
-					"Problem setting up for addCallbackBuffer: " + e.toString());
-		}
-	}
-
-	private Runnable autofocusrunner = new Runnable() {
-
-		@Override
-		public void run() {
-			mCamera.autoFocus(autocallback);
-		}
-	};
-
-	private Camera.AutoFocusCallback autocallback = new Camera.AutoFocusCallback() {
-
-		@Override
-		public void onAutoFocus(boolean success, Camera camera) {
-			if (!success)
-				postautofocus(1000);
-		}
-	};
-
-	/**
-	 * This method will list all methods of the android.hardware.Camera class,
-	 * even the hidden ones. With the information it provides, you can use the
-	 * same approach I took below to expose methods that were written but hidden
-	 * in eclair
-	 */
-	private void listAllCameraMethods() {
-		try {
-			Class<?> c = Class.forName("android.hardware.Camera");
-			Method[] m = c.getMethods();
-			for (int i = 0; i < m.length; i++) {
-				Log.d("NativePreviewer", "  method:" + m[i].toString());
-			}
-		} catch (Exception e) {
-			// TODO Auto-generated catch block
-			Log.e("NativePreviewer", e.toString());
-		}
-	}
-
-	private void initCamera(SurfaceHolder holder) throws InterruptedException {
-		if (mCamera == null) {
-			// The Surface has been created, acquire the camera and tell it
-			// where
-			// to draw.
-			int i = 0;
-			while (i++ < 5) {
-				try {
-					mCamera = Camera.open();
-					break;
-				} catch (RuntimeException e) {
-					Thread.sleep(200);
-				}
-			}
-			try {
-				mCamera.setPreviewDisplay(holder);
-			} catch (IOException exception) {
-				mCamera.release();
-				mCamera = null;
-
-			} catch (RuntimeException e) {
-				Log.e("camera", "stacktrace", e);
-			}
-		}
-	}
-
-	private void releaseCamera() {
-		if (mCamera != null) {
-			// Surface will be destroyed when we return, so stop the preview.
-			// Because the CameraDevice object is not a shared resource, it's
-			// very
-			// important to release it when the activity is paused.
-			mCamera.stopPreview();
-			mCamera.release();
-		}
-
-		// processor = null;
-		mCamera = null;
-		mAcb = null;
-		mPCWB = null;
-	}
-
-	private Handler handler = new Handler();
-
-	private Date start;
-	private int fcount = 0;
-	private boolean hasAutoFocus = false;
-	private SurfaceHolder mHolder;
-	private Camera mCamera;
-
-	private NativeProcessor processor;
-
-	private int preview_width, preview_height;
-	private int pixelformat;
-	private PixelFormat pixelinfo;
-
-	public void setGrayscale(boolean b) {
-		processor.setGrayscale(b);
-		
-	}
-
-}
-
diff --git a/android/android-opencv/src/com/opencv/camera/NativeProcessor.java b/android/android-opencv/src/com/opencv/camera/NativeProcessor.java
deleted file mode 100644
index 4dce3bb617..0000000000
--- a/android/android-opencv/src/com/opencv/camera/NativeProcessor.java
+++ /dev/null
@@ -1,285 +0,0 @@
-package com.opencv.camera;
-
-import java.util.LinkedList;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
-import android.graphics.PixelFormat;
-import android.util.Log;
-
-import com.opencv.jni.image_pool;
-import com.opencv.jni.opencv;
-
-/** The NativeProcessor is a native processing stack engine.
- * 
- * What this means is that the NativeProcessor handles loading
- * live camera frames into native memory space, i.e. the image_pool
- * and then calling a stack of PoolCallback's and passing them the
- * image_pool.
- * 
- * The image_pool index 0 is populated with the live video image
- * 
- * And any modifications to this the pool are in place, so you may
- * pass on changes to the pool to the next PoolCallback in the stack.
- *
- */
-public class NativeProcessor {
-	/** Users that would like to be able to have access to live video frames
-	 * should implement a PoolCallback
-	 * the idx and pool contain the images, specifically at idx == 0 is the
-	 * live video frame.
-	 */
-	static public interface PoolCallback {
-		void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor);
-	}
-
-	
-
-	/**At every frame, each PoolCallback is called in order and is passed the
-	 * the same pool and index
-	 * 
-	 * @param stack  A list of PoolCallback objects, that will be called in order
-	 */
-	public void addCallbackStack(LinkedList<PoolCallback> stack) {
-
-		try {
-			while (!stacklock.tryLock(10, TimeUnit.MILLISECONDS)) {
-
-			}
-			try {
-				nextStack = stack;
-			} finally {
-				stacklock.unlock();
-			}
-		} catch (InterruptedException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-
-		}
-
-	}
-
-	/**
-	 * Create a NativeProcessor. The processor will not start running until
-	 * start is called, at which point it will operate in its own thread and
-	 * sleep until a post is called. The processor should not be started until
-	 * an onSurfaceChange event, and should be shut down when the surface is
-	 * destroyed by calling interupt.
-	 * 
-	 */
-	public NativeProcessor() {
-		gray_scale_only = false;
-	}
-
-	
-	
-	/** Grayscale only is much faster because the yuv does not get decoded, and grayscale is only one
-	 * byter per pixel - giving fast opengl texture loading.
-	 * 
-	 * You still have access to the whole yuv image, but grayscale is only immediately available to
-	 * use without further effort.
-	 * 
-	 * Suggestion - use grayscale only and save your yuv images to disk if you would like color images
-	 * 
-	 * Also, in grayscale mode, the images in the pool are only single channel, so please keep this in mind
-	 * when accessing the color images - check the cv::Mat::channels() or cv::Mat::type() if your messing
-	 * with color channels
-	 * 
-	 * @param grayscale true if you want to only process grayscale images
-	 */
-	public void setGrayscale(boolean grayscale){
-		gray_scale_only = grayscale;
-	}
-	
-
-	/**
-	 * A callback that allows the NativeProcessor to pass back the buffer when
-	 * it has completed processing a frame.
-	 */
-	static protected interface NativeProcessorCallback {
-		/**
-		 * Called after processing, meant to be recieved by the NativePreviewer
-		 * wich reuses the byte buffer for the camera preview...
-		 * 
-		 * @param buffer
-		 *            the buffer passed to the NativeProcessor with post.
-		 */
-		void onDoneNativeProcessing(byte[] buffer);
-	}
-
-	
-	protected void stop() {
-		mthread.interrupt();
-		try {
-			mthread.join();
-		} catch (InterruptedException e) {
-			Log.w("NativeProcessor",
-					"interupted while stoping " + e.getMessage());
-		}
-		mthread = null;
-	}
-
-	protected void start() {
-		mthread = new ProcessorThread();
-		mthread.start();
-	}
-	/**
-	 * post is used to notify the processor that a preview frame is ready, this
-	 * will return almost immediately. if the processor is busy, returns false
-	 * and is essentially a nop.
-	 * 
-	 * @param buffer
-	 *            a preview frame from the Android Camera onPreviewFrame
-	 *            callback
-	 * @param width
-	 *            of preview frame
-	 * @param height
-	 *            of preview frame
-	 * @param format
-	 *            of preview frame
-	 * @return true if the processor wasn't busy and accepted the post, false if
-	 *         the processor is still processing.
-	 */
-
-	protected boolean post(byte[] buffer, int width, int height, int format,
-			long timestamp, NativeProcessorCallback callback) {
-
-		lock.lock();
-		try {
-			NPPostObject pobj = new NPPostObject(buffer, width, height, format,
-					timestamp, callback);
-			postobjects.addFirst(pobj);
-		} finally {
-			lock.unlock();
-		}
-		return true;
-
-	}
-	
-	private class ProcessorThread extends Thread {
-
-		private void process(NPPostObject pobj) throws Exception {
-
-			if (pobj.format == PixelFormat.YCbCr_420_SP) {
-				// add as color image, because we know how to decode this
-				opencv.addYUVtoPool(pool, pobj.buffer, 0, pobj.width,
-						pobj.height, gray_scale_only);
-
-			} else if (pobj.format == PixelFormat.YCbCr_422_SP) {
-				// add as gray image, because this format is not coded
-				// for...//TODO figure out how to decode this
-				// format
-				opencv.addYUVtoPool(pool, pobj.buffer, 0, pobj.width,
-						pobj.height, true);
-			} else
-				throw new Exception("bad pixel format!");
-
-			for (PoolCallback x : stack) {
-				if (interrupted()) {
-					throw new InterruptedException(
-							"Native Processor interupted while processing");
-				}
-				x.process(0, pool, pobj.timestamp, NativeProcessor.this);
-			}
-
-			pobj.done(); // tell the postobject that we're done doing
-							// all the processing.
-
-		}
-
-		@Override
-		public void run() {
-
-			try {
-				while (true) {
-					yield();
-
-					while (!stacklock.tryLock(5, TimeUnit.MILLISECONDS)) {
-					}
-					try {
-						if (nextStack != null) {
-							stack = nextStack;
-							nextStack = null;
-						}
-					} finally {
-						stacklock.unlock();
-					}
-
-					NPPostObject pobj = null;
-
-					while (!lock.tryLock(5, TimeUnit.MILLISECONDS)) {
-					}
-					try {
-						if (postobjects.isEmpty())
-							continue;
-						pobj = postobjects.removeLast();
-
-					} finally {
-						lock.unlock();
-
-					}
-
-					if (interrupted())
-						throw new InterruptedException();
-
-					if (stack != null && pobj != null)
-						process(pobj);
-
-				}
-			} catch (InterruptedException e) {
-
-				Log.i("NativeProcessor",
-						"native processor interupted, ending now");
-
-			} catch (Exception e) {
-
-				e.printStackTrace();
-			} finally {
-
-			}
-		}
-
-	}
-	
-	static private class NPPostObject {
-		public NPPostObject(byte[] buffer, int width, int height, int format,
-				long timestamp, NativeProcessorCallback callback) {
-			this.buffer = buffer;
-			this.width = width;
-			this.height = height;
-			this.format = format;
-			this.timestamp = timestamp;
-			this.callback = callback;
-		}
-
-		public void done() {
-			callback.onDoneNativeProcessing(buffer);
-
-		}
-
-		int width, height;
-		byte[] buffer;
-		int format;
-		long timestamp;
-		NativeProcessorCallback callback;
-	}
-
-
-	private LinkedList<NPPostObject> postobjects = new LinkedList<NPPostObject>();
-
-	private image_pool pool = new image_pool();
-
-	private final Lock lock = new ReentrantLock();
-
-	private LinkedList<PoolCallback> stack = new LinkedList<PoolCallback>();
-	private boolean gray_scale_only;
-	
-	private Lock stacklock = new ReentrantLock();
-
-	private LinkedList<PoolCallback> nextStack;
-	
-	private ProcessorThread mthread;
-
-}
\ No newline at end of file
diff --git a/android/android-opencv/src/com/opencv/opengl/GL2CameraViewer.java b/android/android-opencv/src/com/opencv/opengl/GL2CameraViewer.java
deleted file mode 100644
index 237ae8251c..0000000000
--- a/android/android-opencv/src/com/opencv/opengl/GL2CameraViewer.java
+++ /dev/null
@@ -1,411 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.opencv.opengl;
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-import javax.microedition.khronos.egl.EGL10;
-import javax.microedition.khronos.egl.EGLConfig;
-import javax.microedition.khronos.egl.EGLContext;
-import javax.microedition.khronos.egl.EGLDisplay;
-import javax.microedition.khronos.opengles.GL10;
-
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.jni.glcamera;
-import com.opencv.jni.image_pool;
-
-import android.content.Context;
-import android.graphics.PixelFormat;
-import android.opengl.GLSurfaceView;
-import android.util.AttributeSet;
-import android.util.Log;
-
-
-
-/**
- * A simple GLSurfaceView sub-class that demonstrate how to perform
- * OpenGL ES 2.0 rendering into a GL Surface. Note the following important
- * details:
- *
- * - The class must use a custom context factory to enable 2.0 rendering.
- *   See ContextFactory class definition below.
- *
- * - The class must use a custom EGLConfigChooser to be able to select
- *   an EGLConfig that supports 2.0. This is done by providing a config
- *   specification to eglChooseConfig() that has the attribute
- *   EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
- *   set. See ConfigChooser class definition below.
- *
- * - The class must select the surface's format, then choose an EGLConfig
- *   that matches it exactly (with regards to red/green/blue/alpha channels
- *   bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
- */
-public class GL2CameraViewer extends GLSurfaceView{
-    private static String TAG = "GL2JNIView";
-    private static final boolean DEBUG = false;
- 
-	private PoolCallback poolcallback = new PoolCallback() {
-		
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor){
-		
-			
-				drawMatToGL(idx, pool);
-				
-				requestRender();
-			
-			
-		}
-	};
-
-	 public GL2CameraViewer(Context context,AttributeSet attributeSet) {
-	        super(context,attributeSet);
-	        
-	        init(false, 0, 0);
-	        setZOrderMediaOverlay(true);
-	 }
-    public GL2CameraViewer(Context context) {
-        super(context);
-        init(false, 0, 0);
-        setZOrderMediaOverlay(true);
-    }
-
-    public GL2CameraViewer(Context context, boolean translucent, int depth, int stencil) {
-        super(context);
-        init(translucent, depth, stencil);
-        setZOrderMediaOverlay(true);
-    }
-
-    private void init(boolean translucent, int depth, int stencil) {
-
-    	
-        /* By default, GLSurfaceView() creates a RGB_565 opaque surface.
-         * If we want a translucent one, we should change the surface's
-         * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
-         * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
-         */
-        if (translucent) {
-            this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
-        }
-
-        /* Setup the context factory for 2.0 rendering.
-         * See ContextFactory class definition below
-         */
-        setEGLContextFactory(new ContextFactory());
-
-        /* We need to choose an EGLConfig that matches the format of
-         * our surface exactly. This is going to be done in our
-         * custom config chooser. See ConfigChooser class definition
-         * below.
-         */
-        setEGLConfigChooser( translucent ?
-                             new ConfigChooser(8, 8, 8, 8, depth, stencil) :
-                             new ConfigChooser(5, 6, 5, 0, depth, stencil) );
-
-        /* Set the renderer responsible for frame rendering */
-        setRenderer(new Renderer());
-        setRenderMode(RENDERMODE_WHEN_DIRTY);
-        
-    }
-
-    private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
-        private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
-        public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
-            Log.w(TAG, "creating OpenGL ES 2.0 context");
-            checkEglError("Before eglCreateContext", egl);
-            int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
-            EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
-            checkEglError("After eglCreateContext", egl);
-            return context;
-        }
-
-        public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
-            egl.eglDestroyContext(display, context);
-        }
-    }
-
-    private static void checkEglError(String prompt, EGL10 egl) {
-        int error;
-        while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
-            Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
-        }
-    }
-
-    private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
-
-        public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
-            mRedSize = r;
-            mGreenSize = g;
-            mBlueSize = b;
-            mAlphaSize = a;
-            mDepthSize = depth;
-            mStencilSize = stencil;
-        }
-
-        /* This EGL config specification is used to specify 2.0 rendering.
-         * We use a minimum size of 4 bits for red/green/blue, but will
-         * perform actual matching in chooseConfig() below.
-         */
-        private static int EGL_OPENGL_ES2_BIT = 4;
-        private static int[] s_configAttribs2 =
-        {
-            EGL10.EGL_RED_SIZE, 4,
-            EGL10.EGL_GREEN_SIZE, 4,
-            EGL10.EGL_BLUE_SIZE, 4,
-            EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
-            EGL10.EGL_NONE
-        };
-
-        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
-
-            /* Get the number of minimally matching EGL configurations
-             */
-            int[] num_config = new int[1];
-            egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);
-
-            int numConfigs = num_config[0];
-
-            if (numConfigs <= 0) {
-                throw new IllegalArgumentException("No configs match configSpec");
-            }
-
-            /* Allocate then read the array of minimally matching EGL configs
-             */
-            EGLConfig[] configs = new EGLConfig[numConfigs];
-            egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
-
-            if (DEBUG) {
-                 printConfigs(egl, display, configs);
-            }
-            /* Now return the "best" one
-             */
-            return chooseConfig(egl, display, configs);
-        }
-
-        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
-                EGLConfig[] configs) {
-            for(EGLConfig config : configs) {
-                int d = findConfigAttrib(egl, display, config,
-                        EGL10.EGL_DEPTH_SIZE, 0);
-                int s = findConfigAttrib(egl, display, config,
-                        EGL10.EGL_STENCIL_SIZE, 0);
-
-                // We need at least mDepthSize and mStencilSize bits
-                if (d < mDepthSize || s < mStencilSize)
-                    continue;
-
-                // We want an *exact* match for red/green/blue/alpha
-                int r = findConfigAttrib(egl, display, config,
-                        EGL10.EGL_RED_SIZE, 0);
-                int g = findConfigAttrib(egl, display, config,
-                            EGL10.EGL_GREEN_SIZE, 0);
-                int b = findConfigAttrib(egl, display, config,
-                            EGL10.EGL_BLUE_SIZE, 0);
-                int a = findConfigAttrib(egl, display, config,
-                        EGL10.EGL_ALPHA_SIZE, 0);
-
-                if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
-                    return config;
-            }
-            return null;
-        }
-
-        private int findConfigAttrib(EGL10 egl, EGLDisplay display,
-                EGLConfig config, int attribute, int defaultValue) {
-
-            if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
-                return mValue[0];
-            }
-            return defaultValue;
-        }
-
-        private void printConfigs(EGL10 egl, EGLDisplay display,
-            EGLConfig[] configs) {
-            int numConfigs = configs.length;
-            Log.w(TAG, String.format("%d configurations", numConfigs));
-            for (int i = 0; i < numConfigs; i++) {
-                Log.w(TAG, String.format("Configuration %d:\n", i));
-                printConfig(egl, display, configs[i]);
-            }
-        }
-
-        private void printConfig(EGL10 egl, EGLDisplay display,
-                EGLConfig config) {
-            int[] attributes = {
-                    EGL10.EGL_BUFFER_SIZE,
-                    EGL10.EGL_ALPHA_SIZE,
-                    EGL10.EGL_BLUE_SIZE,
-                    EGL10.EGL_GREEN_SIZE,
-                    EGL10.EGL_RED_SIZE,
-                    EGL10.EGL_DEPTH_SIZE,
-                    EGL10.EGL_STENCIL_SIZE,
-                    EGL10.EGL_CONFIG_CAVEAT,
-                    EGL10.EGL_CONFIG_ID,
-                    EGL10.EGL_LEVEL,
-                    EGL10.EGL_MAX_PBUFFER_HEIGHT,
-                    EGL10.EGL_MAX_PBUFFER_PIXELS,
-                    EGL10.EGL_MAX_PBUFFER_WIDTH,
-                    EGL10.EGL_NATIVE_RENDERABLE,
-                    EGL10.EGL_NATIVE_VISUAL_ID,
-                    EGL10.EGL_NATIVE_VISUAL_TYPE,
-                    0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
-                    EGL10.EGL_SAMPLES,
-                    EGL10.EGL_SAMPLE_BUFFERS,
-                    EGL10.EGL_SURFACE_TYPE,
-                    EGL10.EGL_TRANSPARENT_TYPE,
-                    EGL10.EGL_TRANSPARENT_RED_VALUE,
-                    EGL10.EGL_TRANSPARENT_GREEN_VALUE,
-                    EGL10.EGL_TRANSPARENT_BLUE_VALUE,
-                    0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
-                    0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
-                    0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
-                    0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
-                    EGL10.EGL_LUMINANCE_SIZE,
-                    EGL10.EGL_ALPHA_MASK_SIZE,
-                    EGL10.EGL_COLOR_BUFFER_TYPE,
-                    EGL10.EGL_RENDERABLE_TYPE,
-                    0x3042 // EGL10.EGL_CONFORMANT
-            };
-            String[] names = {
-                    "EGL_BUFFER_SIZE",
-                    "EGL_ALPHA_SIZE",
-                    "EGL_BLUE_SIZE",
-                    "EGL_GREEN_SIZE",
-                    "EGL_RED_SIZE",
-                    "EGL_DEPTH_SIZE",
-                    "EGL_STENCIL_SIZE",
-                    "EGL_CONFIG_CAVEAT",
-                    "EGL_CONFIG_ID",
-                    "EGL_LEVEL",
-                    "EGL_MAX_PBUFFER_HEIGHT",
-                    "EGL_MAX_PBUFFER_PIXELS",
-                    "EGL_MAX_PBUFFER_WIDTH",
-                    "EGL_NATIVE_RENDERABLE",
-                    "EGL_NATIVE_VISUAL_ID",
-                    "EGL_NATIVE_VISUAL_TYPE",
-                    "EGL_PRESERVED_RESOURCES",
-                    "EGL_SAMPLES",
-                    "EGL_SAMPLE_BUFFERS",
-                    "EGL_SURFACE_TYPE",
-                    "EGL_TRANSPARENT_TYPE",
-                    "EGL_TRANSPARENT_RED_VALUE",
-                    "EGL_TRANSPARENT_GREEN_VALUE",
-                    "EGL_TRANSPARENT_BLUE_VALUE",
-                    "EGL_BIND_TO_TEXTURE_RGB",
-                    "EGL_BIND_TO_TEXTURE_RGBA",
-                    "EGL_MIN_SWAP_INTERVAL",
-                    "EGL_MAX_SWAP_INTERVAL",
-                    "EGL_LUMINANCE_SIZE",
-                    "EGL_ALPHA_MASK_SIZE",
-                    "EGL_COLOR_BUFFER_TYPE",
-                    "EGL_RENDERABLE_TYPE",
-                    "EGL_CONFORMANT"
-            };
-            int[] value = new int[1];
-            for (int i = 0; i < attributes.length; i++) {
-                int attribute = attributes[i];
-                String name = names[i];
-                if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
-                    Log.w(TAG, String.format("  %s: %d\n", name, value[0]));
-                } else {
-                    // Log.w(TAG, String.format("  %s: failed\n", name));
-                    while (egl.eglGetError() != EGL10.EGL_SUCCESS);
-                }
-            }
-        }
-
-        // Subclasses can adjust these values:
-        protected int mRedSize;
-        protected int mGreenSize;
-        protected int mBlueSize;
-        protected int mAlphaSize;
-        protected int mDepthSize;
-        protected int mStencilSize;
-        private int[] mValue = new int[1];
-    }
-
-    glcamera mglcamera;
-    public void drawMatToGL(int idx, image_pool pool){
-    	if(mglcamera != null)
-    		mglcamera.drawMatToGL(idx, pool);
-    	else
-    		Log.e("android-opencv", "null glcamera!!!!");
-    }
-    public void clear(){
-    	if(mglcamera != null)
-    		mglcamera.clear();
-    	else
-    		Log.e("android-opencv", "null glcamera!!!!");
-    }
-    
-    private class Renderer implements GLSurfaceView.Renderer {
-    	
-        public void onDrawFrame(GL10 gl) {
-        	
-            mglcamera.step();
-        }
-
-        public void onSurfaceChanged(GL10 gl, int width, int height) {
-        	
-            mglcamera.init(width, height);
-        }
-
-        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-           
-        }
-    }
-
-
-	@Override
-	public void onPause() {
-		mglcamera = null;
-		// TODO Auto-generated method stub
-		super.onPause();
-		
-	}
-
-	@Override
-	public void onResume() {
-		mglcamera = new glcamera();
-		// TODO Auto-generated method stub
-		super.onResume();
-		
-	}
-
-	public PoolCallback getDrawCallback() {
-		// TODO Auto-generated method stub
-		return poolcallback;
-	}
-
-
-}
diff --git a/android/android-opencv/src/com/opencv/utils/BitmapBridge.java b/android/android-opencv/src/com/opencv/utils/BitmapBridge.java
deleted file mode 100644
index 573e7ae05c..0000000000
--- a/android/android-opencv/src/com/opencv/utils/BitmapBridge.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package com.opencv.utils;
-
-import java.nio.ByteBuffer;
-
-import com.opencv.jni.Mat;
-import com.opencv.jni.Size;
-import com.opencv.jni.opencv;
-
-import android.graphics.Bitmap;
-import android.graphics.Bitmap.Config;
-
-public class BitmapBridge {
-	static void copyBitmap(Bitmap bmap, Mat mat) throws Exception {
-		if ((bmap.getConfig() == null) || bmap.getConfig() == Config.ARGB_8888)
-			throw new Exception("bad config");
-		Size sz = new Size(bmap.getWidth(), bmap.getHeight());
-		mat.create(sz, opencv.CV_8UC4);
-		ByteBuffer buffer = ByteBuffer.allocate(4 * bmap.getWidth()
-				* bmap.getHeight());
-		bmap.copyPixelsToBuffer(buffer);
-		opencv.copyBufferToMat(mat, buffer);
-
-	}
-
-	static Bitmap matToBitmap(Mat mat) {
-		Bitmap bmap = Bitmap.createBitmap(mat.getCols(), mat.getRows(),
-				Config.ARGB_8888);
-		ByteBuffer buffer = ByteBuffer.allocate(4 * bmap.getWidth()
-				* bmap.getHeight());
-		opencv.copyMatToBuffer(buffer, mat);
-		bmap.copyPixelsFromBuffer(buffer);
-		return bmap;
-	}
-}
diff --git a/android/android.toolchain.cmake b/android/android.toolchain.cmake
index fab1c7f324..640f469cec 100644
--- a/android/android.toolchain.cmake
+++ b/android/android.toolchain.cmake
@@ -1,5 +1,5 @@
 # ----------------------------------------------------------------------------
-#  Android CMake toolchain file, for use with the ndk r5
+#  Android CMake toolchain file, for use with the ndk r5,r6
 #  See home page: http://code.google.com/p/android-cmake/
 #
 #  Usage Linux:
@@ -16,13 +16,13 @@
 #     You need native port of make to build your project.
 #     For example this one: http://gnuwin32.sourceforge.net/packages/make.htm
 #
-#   $ SET ANDROID_NDK=C:\<absolute path to NDK>\android-ndk-r5c
+#   $ SET ANDROID_NDK=C:\<absolute path to NDK>\android-ndk-r6
 #   $ cmake.exe -G"Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=<path to this file>\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM=C:\<absolute path to make>\make.exe ..
 #   $ C:\<absolute path to make>\make.exe
 #
 #
 #  Toolchain options (can be set as cmake parameters: -D<option_name>=<value>):
-#    ANDROID_NDK=/opt/android-ndk-r5c - path to NDK root.
+#    ANDROID_NDK=/opt/android-ndk-r6 - path to NDK root.
 #      Can be set as environment variable.
 #
 #    ANDROID_NDK_TOOLCHAIN_ROOT=/opt/android-toolchain - path to standalone toolchain.
@@ -38,8 +38,6 @@
 #
 #    NO_UNDEFINED=true - set true to show all undefined symbols will as linker errors even if they are not used.
 #
-#    NO_SWIG=false - set true to disable SWIG package
-#
 #
 #  Toolcahin will search for NDK/toolchain in following order:
 #    ANDROID_NDK - cmake parameter
@@ -94,6 +92,13 @@
 #     [~] default NDK path is updated for version r5c 
 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
 #     [~] toolchain install directory is added to linker paths
+#     [-] removed SWIG-related stuff from toolchain
+#     [+] added macro find_host_package, find_host_program to search packages/programs on host system
+#     [~] fixed path to STL library
+#   - modified July 2011 Andrey Kamaev andrey.kamaev@itseez.com
+#     [~] fixed options caching
+#     [~] search for all supported NDK versions
+#     [~] allowed spaces in NDK path
 # ----------------------------------------------------------------------------
 
 # this one is important
@@ -101,7 +106,8 @@ set( CMAKE_SYSTEM_NAME Linux )
 #this one not so much
 set( CMAKE_SYSTEM_VERSION 1 )
 
-set( ANDROID_NDK_DEFAULT_SEARCH_PATH /opt/android-ndk-r5c )
+set( ANDROID_NDK_DEFAULT_SEARCH_PATH /opt/android-ndk )
+set( ANDROID_NDK_SUPPORTED_VERSIONS -r6 -r5c -r5b -r5 "")
 set( ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH /opt/android-toolchain )
 set( TOOL_OS_SUFFIX "" )
 
@@ -124,21 +130,28 @@ macro( __TOOLCHAIN_DETECT_API_LEVEL _path )
  set( ANDROID_API_LEVEL ${ANDROID_LEVEL_FOUND} CACHE STRING "android API level" FORCE )
 endmacro()
 
-#set path for android NDK -- look
 if( NOT DEFINED ANDROID_NDK )
  set( ANDROID_NDK $ENV{ANDROID_NDK} )
 endif()
 
-if( NOT EXISTS ${ANDROID_NDK} )
- if( EXISTS ${ANDROID_NDK_DEFAULT_SEARCH_PATH} )
-  set ( ANDROID_NDK ${ANDROID_NDK_DEFAULT_SEARCH_PATH} )
-  message( STATUS "Using default path for android NDK ${ANDROID_NDK}" )
-  message( STATUS "If you prefer to use a different location, please define the environment variable: ANDROID_NDK" )
- endif()
+if( NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
+ set( ANDROID_NDK_TOOLCHAIN_ROOT $ENV{ANDROID_NDK_TOOLCHAIN_ROOT} )
 endif()
 
-if( EXISTS ${ANDROID_NDK} )
- set( ANDROID_NDK ${ANDROID_NDK} CACHE PATH "root of the android ndk" FORCE )
+#set path for android NDK -- look
+if( NOT EXISTS "${ANDROID_NDK}" AND NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
+ foreach(ndk_version ${ANDROID_NDK_SUPPORTED_VERSIONS})
+  if( EXISTS ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
+   set ( ANDROID_NDK ${ANDROID_NDK_DEFAULT_SEARCH_PATH}${ndk_version} )
+   message( STATUS "Using default path for android NDK ${ANDROID_NDK}" )
+   message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_NDK" )
+   break()
+  endif()
+ endforeach()
+endif()
+
+if( EXISTS "${ANDROID_NDK}" )
+ set( ANDROID_NDK "${ANDROID_NDK}" CACHE PATH "root of the android ndk" FORCE )
  
  if( APPLE )
   set( NDKSYSTEM "darwin-x86" )
@@ -162,7 +175,7 @@ if( EXISTS ${ANDROID_NDK} )
  if( NOT ANDROID_API_LEVEL GREATER 2 )
   set( ANDROID_API_LEVEL 8)
   message( STATUS "Using default android API level android-${ANDROID_API_LEVEL}" )
-  message( STATUS "If you prefer to use a different API level, please define the environment variable: ANDROID_API_LEVEL" )
+  message( STATUS "  If you prefer to use a different API level, please define the variable: ANDROID_API_LEVEL" )
  endif()
 
  set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/arm-linux-androideabi-4.4.3/prebuilt/${NDKSYSTEM}" )
@@ -174,20 +187,16 @@ if( EXISTS ${ANDROID_NDK} )
  set( BUILD_WITH_ANDROID_NDK True )
 else()
  #try to find toolchain
- if( NOT DEFINED ANDROID_NDK_TOOLCHAIN_ROOT )
-  set( ANDROID_NDK_TOOLCHAIN_ROOT $ENV{ANDROID_NDK_TOOLCHAIN_ROOT} )
- endif()
- 
- if( NOT EXISTS ${ANDROID_NDK_TOOLCHAIN_ROOT} )
-  set( ANDROID_NDK_TOOLCHAIN_ROOT ${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH} )
+ if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
+  set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_DEFAULT_SEARCH_PATH}" )
   message( STATUS "Using default path for toolchain ${ANDROID_NDK_TOOLCHAIN_ROOT}" )
-  message( STATUS "If you prefer to use a different location, please define the environment variable: ANDROID_NDK_TOOLCHAIN_ROOT" )
+  message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_NDK_TOOLCHAIN_ROOT" )
  endif()
 
- set( ANDROID_NDK_TOOLCHAIN_ROOT ${ANDROID_NDK_TOOLCHAIN_ROOT} CACHE PATH "root of the Android NDK standalone toolchain" FORCE )
+ set( ANDROID_NDK_TOOLCHAIN_ROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}" CACHE PATH "root of the Android NDK standalone toolchain" FORCE )
  set( ANDROID_NDK_SYSROOT "${ANDROID_NDK_TOOLCHAIN_ROOT}/sysroot" )
 
- if( NOT EXISTS ${ANDROID_NDK_TOOLCHAIN_ROOT} )
+ if( NOT EXISTS "${ANDROID_NDK_TOOLCHAIN_ROOT}" )
   message( FATAL_ERROR "neither ${ANDROID_NDK} nor ${ANDROID_NDK_TOOLCHAIN_ROOT} does not exist!
     You should either set an environment variable:
       export ANDROID_NDK=~/my-android-ndk
@@ -205,26 +214,28 @@ else()
 endif()
 
 # specify the cross compiler
-set( CMAKE_C_COMPILER   ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-gcc${TOOL_OS_SUFFIX}     CACHE PATH "gcc" FORCE )
-set( CMAKE_CXX_COMPILER ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-g++${TOOL_OS_SUFFIX}     CACHE PATH "g++" FORCE )
+set( CMAKE_C_COMPILER   "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "gcc" FORCE )
+set( CMAKE_CXX_COMPILER "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-g++${TOOL_OS_SUFFIX}"     CACHE PATH "g++" FORCE )
 #there may be a way to make cmake deduce these TODO deduce the rest of the tools
-set( CMAKE_AR           ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ar${TOOL_OS_SUFFIX}      CACHE PATH "archive" FORCE )
-set( CMAKE_LINKER       ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ld${TOOL_OS_SUFFIX}      CACHE PATH "linker" FORCE )
-set( CMAKE_NM           ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-nm${TOOL_OS_SUFFIX}      CACHE PATH "nm" FORCE )
-set( CMAKE_OBJCOPY      ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objcopy${TOOL_OS_SUFFIX} CACHE PATH "objcopy" FORCE )
-set( CMAKE_OBJDUMP      ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objdump${TOOL_OS_SUFFIX} CACHE PATH "objdump" FORCE )
-set( CMAKE_STRIP        ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-strip${TOOL_OS_SUFFIX}   CACHE PATH "strip" FORCE )
-set( CMAKE_RANLIB       ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ranlib${TOOL_OS_SUFFIX}  CACHE PATH "ranlib" FORCE )
+set( CMAKE_AR           "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ar${TOOL_OS_SUFFIX}"      CACHE PATH "archive" FORCE )
+set( CMAKE_LINKER       "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ld${TOOL_OS_SUFFIX}"      CACHE PATH "linker" FORCE )
+set( CMAKE_NM           "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-nm${TOOL_OS_SUFFIX}"      CACHE PATH "nm" FORCE )
+set( CMAKE_OBJCOPY      "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" FORCE )
+set( CMAKE_OBJDUMP      "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" FORCE )
+set( CMAKE_STRIP        "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" FORCE )
+set( CMAKE_RANLIB       "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin/arm-linux-androideabi-ranlib${TOOL_OS_SUFFIX}"  CACHE PATH "ranlib" FORCE )
 
 #setup build targets, mutually exclusive
 set( PossibleArmTargets "armeabi;armeabi-v7a;armeabi-v7a with NEON;armeabi-v7a with VFPV3" )
-set( ARM_TARGET "armeabi-v7a" CACHE STRING "the arm target for android, recommend armeabi-v7a for floating point support and NEON." )
-set_property( CACHE ARM_TARGET PROPERTY STRINGS ${PossibleArmTargets} )
-
 #compatibility junk for previous version of toolchain
 if( DEFINED ARM_TARGETS AND NOT DEFINED ARM_TARGET )
- SET( ARM_TARGET "${ARM_TARGETS}" )
+ set( ARM_TARGET "${ARM_TARGETS}" )
 endif()
+IF( NOT ARM_TARGET)
+ set( ARM_TARGET armeabi-v7a )
+ENDIF()
+set( ARM_TARGET "${ARM_TARGET}" CACHE INTERNAL "the arm target for android, recommend armeabi-v7a for floating point support and NEON." )
+set_property( CACHE ARM_TARGET PROPERTY STRINGS ${PossibleArmTargets} )
 
 #set these flags for client use
 if( ARM_TARGET STREQUAL "armeabi" )
@@ -253,36 +264,42 @@ set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library o
 
 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS OFF CACHE BOOL "")
 if( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS )
- #some cmake standard modules work incorrectly if output paths are changed
- if( EXISTS ${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt )
-  # these paths are required for jni part of Android projects
-  # but they may conflict with traditional unix makefile's folder structure
-  set( LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ARMEABI_NDK_NAME} CACHE PATH "path for android libs" FORCE )
-  set( EXECUTABLE_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ARMEABI_NDK_NAME} CACHE PATH "Output directory for applications" FORCE)
+ if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ARMEABI_NDK_NAME}" CACHE PATH "Output directory for applications")
+ else()
+  set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications")
  endif()
- set( CMAKE_INSTALL_PREFIX ${ANDROID_NDK_TOOLCHAIN_ROOT}/user/${ARMEABI_NDK_NAME} CACHE STRING "path for installing" FORCE )
+ set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ARMEABI_NDK_NAME}" CACHE PATH "path for android libs")
+ set( CMAKE_INSTALL_PREFIX "${ANDROID_NDK_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
 endif()
 SET( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ON CACHE INTERNAL "" FORCE)
 
 # where is the target environment 
-set( CMAKE_FIND_ROOT_PATH ${ANDROID_NDK_TOOLCHAIN_ROOT}/bin ${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi ${ANDROID_NDK_SYSROOT} ${CMAKE_INSTALL_PREFIX} ${CMAKE_INSTALL_PREFIX}/share )
+set( CMAKE_FIND_ROOT_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/bin" "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi" "${ANDROID_NDK_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" )
 
 if( BUILD_WITH_ANDROID_NDK )
  set( STL_PATH "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++" )
  set( STL_LIBRARIES_PATH "${STL_PATH}/libs/${ARMEABI_NDK_NAME}" )
- include_directories( ${STL_PATH}/include ${STL_LIBRARIES_PATH}/include )
+ include_directories(SYSTEM "${STL_PATH}/include" "${STL_LIBRARIES_PATH}/include" )
+# if ( NOT ARMEABI AND NOT FORCE_ARM )
+#  set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
+# endif()
 endif()
 
 if( BUILD_WITH_ANDROID_NDK_TOOLCHAIN )
- set( STL_LIBRARIES_PATH "${CMAKE_INSTALL_PREFIX}/lib" )
+ set( STL_LIBRARIES_PATH "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/lib" )
+ if( NOT ARMEABI )
+  set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/${CMAKE_SYSTEM_PROCESSOR}" )
+ endif()
+ if( NOT FORCE_ARM )
+  set( STL_LIBRARIES_PATH "${STL_LIBRARIES_PATH}/thumb" )
+ endif()
  #for some reason this is needed? TODO figure out why...
- include_directories( ${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi )
+ include_directories(SYSTEM "${ANDROID_NDK_TOOLCHAIN_ROOT}/arm-linux-androideabi/include/c++/4.4.3/arm-linux-androideabi" )
 endif()
 
-# allow programs like swig to be found -- but can be deceiving for
-# system tool dependencies.
-set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 # only search for libraries and includes in the ndk toolchain
+set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 
@@ -301,8 +318,14 @@ else()
 endif()
 
 if( BUILD_WITH_ANDROID_NDK )
- set( CMAKE_CXX_FLAGS "--sysroot=${ANDROID_NDK_SYSROOT} ${CMAKE_CXX_FLAGS}" )
- set( CMAKE_C_FLAGS "--sysroot=${ANDROID_NDK_SYSROOT} ${CMAKE_C_FLAGS}" )
+ set( CMAKE_CXX_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_CXX_FLAGS}" )
+ set( CMAKE_C_FLAGS "--sysroot=\"${ANDROID_NDK_SYSROOT}\" ${CMAKE_C_FLAGS}" )
+
+ # workaround for ugly cmake bug - compiler identification replaces all spaces (and somethimes " !!!) in compiler flags with ; symbol
+ # as result identification fails if ANDROID_NDK_SYSROOT contain spaces
+ include(CMakeForceCompiler)
+ CMAKE_FORCE_C_COMPILER("${CMAKE_C_COMPILER}" GNU)
+ CMAKE_FORCE_CXX_COMPILER("${CMAKE_CXX_COMPILER}" GNU)
 endif()
 
 if( ARMEABI_V7A )
@@ -325,7 +348,7 @@ set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "c flags" )
 #-L${LIBCPP_LINK_DIR} -lstdc++ -lsupc++
 #Also, this is *required* to use the following linker flags that routes around
 #a CPU bug in some Cortex-A8 implementations:
-set( LINKER_FLAGS "-Wl,--fix-cortex-a8 -L${STL_LIBRARIES_PATH} -L${CMAKE_INSTALL_PREFIX}/lib -lstdc++ -lsupc++ " )
+set( LINKER_FLAGS "-Wl,--fix-cortex-a8 -L\"${STL_LIBRARIES_PATH}\" -L\"${CMAKE_INSTALL_PREFIX}/libs/${ARMEABI_NDK_NAME}\" -lstdc++ -lsupc++ " )
 
 set( NO_UNDEFINED ON CACHE BOOL "Don't all undefined symbols" )
 if( NO_UNDEFINED )
@@ -340,28 +363,45 @@ set( CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" FORCE
 set( ANDROID True )
 set( BUILD_ANDROID True )
 
-#SWIG junk...
-set( NO_SWIG OFF CACHE BOOL "Don't search for SWIG" )
-if( NOT NO_SWIG )
- #need to search in the  host for swig to be found
- set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH )
- set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH )
- find_package( SWIG QUIET )
- set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
- set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
-
- if( SWIG_FOUND )
-  set( SWIG_USE_FILE ${CMAKE_ROOT}/Modules/UseSWIG.cmake CACHE PATH "Use Swig cmake module" )
-  set( SWIG_OUTPUT_ROOT ${LIBRARY_OUTPUT_PATH_ROOT}/src CACHE PATH "Where swig generated files will be placed relative to, <SWIG_OUTPUT_ROOT>/com/mylib/foo/jni ..." FORCE )
-
-  #convenience macro for swig java packages
-  macro( SET_SWIG_JAVA_PACKAGE package_name )
-   string( REGEX REPLACE "[.]" "/" package_name_output ${package_name} )
-   set( CMAKE_SWIG_OUTDIR ${SWIG_OUTPUT_ROOT}/${package_name_output} )
-   set( CMAKE_SWIG_FLAGS "-package" "\"${package_name}\"" )
-  endmacro()
- else()
-  message( STATUS "SWIG is not found" )
-  set( NO_SWIG ON CACHE BOOL "Don't search for SWIG" FORCE )
+#macro to find packages on the host OS
+macro(find_host_package)
+ set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
+ set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
+ set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
+ if( CMAKE_HOST_WIN32 )
+  SET( WIN32 1 )
+  SET( UNIX )
+ elseif( CMAKE_HOST_APPLE )
+  SET( APPLE 1 )
+  SET( UNIX )
  endif()
-endif()
+ find_package( ${ARGN} )
+ SET( WIN32 )
+ SET( APPLE )
+ SET( UNIX 1)
+ set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
+ set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
+ set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
+endmacro()
+#macro to find programs on the host OS
+macro(find_host_program)
+ set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
+ set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
+ set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
+ if( CMAKE_HOST_WIN32 )
+  SET( WIN32 1 )
+  SET( UNIX )
+ elseif( CMAKE_HOST_APPLE )
+  SET( APPLE 1 )
+  SET( UNIX )
+ endif()
+ find_program( ${ARGN} )
+ SET( WIN32 )
+ SET( APPLE )
+ SET( UNIX 1)
+ set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
+ set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
+ set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
+endmacro()
+
+MARK_AS_ADVANCED(FORCE_ARM NO_UNDEFINED)
diff --git a/android/apps/CVCamera/AndroidManifest.xml b/android/apps/CVCamera/AndroidManifest.xml
deleted file mode 100644
index 227f23ac36..0000000000
--- a/android/apps/CVCamera/AndroidManifest.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.theveganrobot.cvcamera" android:versionCode="7" android:versionName="7.0"
-	>
-	<application android:debuggable="false" android:icon="@drawable/icon">
-		<activity android:name=".CVCamera" android:screenOrientation="landscape"
-			android:configChanges="orientation|keyboardHidden|keyboard"
-			android:label="@string/app_name"
-			>
-			<intent-filter>
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-		</activity>
-		
-		<activity android:name="com.opencv.camera.CameraConfig" android:label="@string/app_name"
-			android:screenOrientation="landscape" 
-			android:configChanges="orientation|keyboardHidden|keyboard">
-		</activity>
-		
-
-	</application>
-
-
-
-	<uses-feature android:glEsVersion="0x00020000" android:required="true"/>
-	<uses-feature android:name="android.hardware.camera" android:required="true"/>
-
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-	 
-
-
-	<uses-sdk android:minSdkVersion="7" android:targetSdkVersion="7" />
-
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
-</manifest> 
\ No newline at end of file
diff --git a/android/apps/CVCamera/CMakeLists.txt b/android/apps/CVCamera/CMakeLists.txt
deleted file mode 100644
index e82fbdf4c3..0000000000
--- a/android/apps/CVCamera/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-
-project(CVCamera)
-
-add_subdirectory(jni)
diff --git a/android/apps/CVCamera/README.txt b/android/apps/CVCamera/README.txt
deleted file mode 100644
index 8bc5b3a90e..0000000000
--- a/android/apps/CVCamera/README.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-see http://code.google.com/p/android-opencv/wiki/CVCamera
-
diff --git a/android/apps/CVCamera/default.properties b/android/apps/CVCamera/default.properties
deleted file mode 100644
index 248b9a0428..0000000000
--- a/android/apps/CVCamera/default.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
-# This file must be checked in Version Control Systems.
-# 
-# To customize properties used by the Ant build system use,
-# "build.properties", and override values to adapt the script to your
-# project structure.
-
-android.library.reference.1=../../android-opencv
-# Project target.
-target=android-7
diff --git a/android/apps/CVCamera/jni/CMakeLists.txt b/android/apps/CVCamera/jni/CMakeLists.txt
deleted file mode 100644
index 3ea00cb19b..0000000000
--- a/android/apps/CVCamera/jni/CMakeLists.txt
+++ /dev/null
@@ -1,62 +0,0 @@
-#########################################################
-# Find opencv and android-opencv
-#########################################################
-
-set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../../build 
-    CACHE PATH "The path where you built opencv for android")
-set(AndroidOpenCV_DIR ${CMAKE_SOURCE_DIR}/../../android-opencv/build 
-    CACHE PATH "The path where you built android-opencv")
-
-find_package(OpenCV REQUIRED)
-FIND_PACKAGE(AndroidOpenCV REQUIRED )
-
-#########################################################
-#c flags, included, and lib dependencies
-#########################################################
-
-#notice the "recycling" of CMAKE_C_FLAGS
-#this is necessary to pick up android flags
-set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-set( LIBRARY_DEPS ${AndroidOpenCV_LIBS} ${OpenCV_LIBS} )
-if(ANDROID)
-  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl)
-endif(ANDROID)
-
-#########################################################
-#SWIG STUFF
-#########################################################
-#the java package to place swig generated java files in
-set(MY_PACKAGE com.theveganrobot.cvcamera.jni)
-
-if(NOT ANDROID)
-  #non android swig and jni
-  #jni is available by default on android
-  find_package(JNI REQUIRED)
-  include_directories(${JNI_INCLUDE_DIRS})
-  FIND_PACKAGE(SWIG)
-endif()
-
-INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
-
-if(ANDROID)
-  #this will set the output path for the java package
-  #and properly create the package declarations in generated java sources
-  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
-endif(ANDROID)
-
-#this add's the swig path for the opencv wrappers
-SET(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} "-I${AndroidOpenCV_SWIG_DIR}" )
-
-SET_SOURCE_FILES_PROPERTIES(cvcamera.i PROPERTIES CPLUSPLUS ON)
-
-#add the swig module, giving it the name, java, and then all of the source files
-SWIG_ADD_MODULE(cvcamera java 
-                cvcamera.i #swig file
-                Processor.cpp #cpp files can be compiled to
-                )
-             
-#link the module like any other   
-target_link_libraries(cvcamera ${LIBRARY_DEPS} )
diff --git a/android/apps/CVCamera/jni/Processor.cpp b/android/apps/CVCamera/jni/Processor.cpp
deleted file mode 100644
index eaf0e5b747..0000000000
--- a/android/apps/CVCamera/jni/Processor.cpp
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * Processor.cpp
- *
- *  Created on: Jun 13, 2010
- *      Author: ethan
- */
-
-#include "Processor.h"
-
-#include <sys/stat.h>
-
-using namespace cv;
-
-Processor::Processor() :
-      stard(20/*max_size*/, 8/*response_threshold*/, 15/*line_threshold_projected*/, 8/*line_threshold_binarized*/, 5/*suppress_nonmax_size*/),
-      fastd(20/*threshold*/, true/*nonmax_suppression*/),
-      surfd(100./*hessian_threshold*/, 1/*octaves*/, 2/*octave_layers*/)
-
-{
-
-}
-
-Processor::~Processor()
-{
-  // TODO Auto-generated destructor stub
-}
-
-void Processor::detectAndDrawFeatures(int input_idx, image_pool* pool, int feature_type)
-{
-  FeatureDetector* fd = 0;
-
-  switch (feature_type)
-  {
-    case DETECT_SURF:
-      fd = &surfd;
-      break;
-    case DETECT_FAST:
-      fd = &fastd;
-      break;
-    case DETECT_STAR:
-      fd = &stard;
-      break;
-  }
-
-  Mat greyimage = pool->getGrey(input_idx);
-
-  Mat img = pool->getImage(input_idx);
-
-  if (img.empty() || greyimage.empty() || fd == 0)
-    return; //no image at input_idx!
-
-
-  keypoints.clear();
-
-  //if(grayimage->step1() > sizeof(uchar)) return;
-  //cvtColor(*img,*grayimage,CV_RGB2GRAY);
-
-
-  fd->detect(greyimage, keypoints);
-
-  for (vector<KeyPoint>::const_iterator it = keypoints.begin(); it != keypoints.end(); ++it)
-  {
-    circle(img, it->pt, 3, cvScalar(255, 0, 255, 0));
-  }
-
-  //pool->addImage(output_idx,outimage);
-
-}
-static double computeReprojectionErrors(const vector<vector<Point3f> >& objectPoints,
-                                        const vector<vector<Point2f> >& imagePoints, const vector<Mat>& rvecs,
-                                        const vector<Mat>& tvecs, const Mat& cameraMatrix, const Mat& distCoeffs,
-                                        vector<float>& perViewErrors)
-{
-  vector<Point2f> imagePoints2;
-  int i, totalPoints = 0;
-  double totalErr = 0, err;
-  perViewErrors.resize(objectPoints.size());
-
-  for (i = 0; i < (int)objectPoints.size(); i++)
-  {
-    projectPoints(Mat(objectPoints[i]), rvecs[i], tvecs[i], cameraMatrix, distCoeffs, imagePoints2);
-    err = norm(Mat(imagePoints[i]), Mat(imagePoints2), CV_L1);
-    int n = (int)objectPoints[i].size();
-    perViewErrors[i] = err / n;
-    totalErr += err;
-    totalPoints += n;
-  }
-
-  return totalErr / totalPoints;
-}
-
-static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners)
-{
-  corners.resize(0);
-
-  for (int i = 0; i < boardSize.height; i++)
-    for (int j = 0; j < boardSize.width; j++)
-      corners.push_back(Point3f(float(j * squareSize), float(i * squareSize), 0));
-}
-
-/**from opencv/samples/cpp/calibration.cpp
- *
- */
-static bool runCalibration(vector<vector<Point2f> > imagePoints, Size imageSize, Size boardSize, float squareSize,
-                           float aspectRatio, int flags, Mat& cameraMatrix, Mat& distCoeffs, vector<Mat>& rvecs,
-                           vector<Mat>& tvecs, vector<float>& reprojErrs, double& totalAvgErr)
-{
-  cameraMatrix = Mat::eye(3, 3, CV_64F);
-  if (flags & CV_CALIB_FIX_ASPECT_RATIO)
-    cameraMatrix.at<double> (0, 0) = aspectRatio;
-
-  distCoeffs = Mat::zeros(5, 1, CV_64F);
-
-  vector<vector<Point3f> > objectPoints(1);
-  calcChessboardCorners(boardSize, squareSize, objectPoints[0]);
-  for (size_t i = 1; i < imagePoints.size(); i++)
-    objectPoints.push_back(objectPoints[0]);
-
-  calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags);
-
-  bool ok = checkRange(cameraMatrix, CV_CHECK_QUIET) && checkRange(distCoeffs, CV_CHECK_QUIET);
-
-  totalAvgErr
-      = computeReprojectionErrors(objectPoints, imagePoints, rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
-
-  return ok;
-}
-
-bool Processor::detectAndDrawChessboard(int idx, image_pool* pool)
-{
-
-  Mat grey = pool->getGrey(idx);
-  if (grey.empty())
-    return false;
-  vector<Point2f> corners;
-
-  IplImage iplgrey = grey;
-  if (!cvCheckChessboard(&iplgrey, Size(6, 8)))
-    return false;
-  bool patternfound = findChessboardCorners(grey, Size(6, 8), corners);
-
-  Mat img = pool->getImage(idx);
-
-  if (corners.size() < 1)
-    return false;
-
-  cornerSubPix(grey, corners, Size(11, 11), Size(-1, -1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
-
-  if (patternfound)
-    imagepoints.push_back(corners);
-
-  drawChessboardCorners(img, Size(6, 8), Mat(corners), patternfound);
-
-  imgsize = grey.size();
-
-  return patternfound;
-
-}
-
-void Processor::drawText(int i, image_pool* pool, const char* ctext)
-{
-  // Use "y" to show that the baseLine is about
-  string text = ctext;
-  int fontFace = FONT_HERSHEY_COMPLEX_SMALL;
-  double fontScale = .8;
-  int thickness = .5;
-
-  Mat img = pool->getImage(i);
-
-  int baseline = 0;
-  Size textSize = getTextSize(text, fontFace, fontScale, thickness, &baseline);
-  baseline += thickness;
-
-  // center the text
-  Point textOrg((img.cols - textSize.width) / 2, (img.rows - textSize.height * 2));
-
-  // draw the box
-  rectangle(img, textOrg + Point(0, baseline), textOrg + Point(textSize.width, -textSize.height), Scalar(0, 0, 255),
-            CV_FILLED);
-  // ... and the baseline first
-  line(img, textOrg + Point(0, thickness), textOrg + Point(textSize.width, thickness), Scalar(0, 0, 255));
-
-  // then put the text itself
-  putText(img, text, textOrg, fontFace, fontScale, Scalar::all(255), thickness, 8);
-}
-void saveCameraParams(const string& filename, Size imageSize, Size boardSize, float squareSize, float aspectRatio,
-                      int flags, const Mat& cameraMatrix, const Mat& distCoeffs, const vector<Mat>& rvecs,
-                      const vector<Mat>& tvecs, const vector<float>& reprojErrs,
-                      const vector<vector<Point2f> >& imagePoints, double totalAvgErr)
-{
-  FileStorage fs(filename, FileStorage::WRITE);
-
-  time_t t;
-  time(&t);
-  struct tm *t2 = localtime(&t);
-  char buf[1024];
-  strftime(buf, sizeof(buf) - 1, "%c", t2);
-
-  fs << "calibration_time" << buf;
-
-  if (!rvecs.empty() || !reprojErrs.empty())
-    fs << "nframes" << (int)std::max(rvecs.size(), reprojErrs.size());
-  fs << "image_width" << imageSize.width;
-  fs << "image_height" << imageSize.height;
-  fs << "board_width" << boardSize.width;
-  fs << "board_height" << boardSize.height;
-  fs << "squareSize" << squareSize;
-
-  if (flags & CV_CALIB_FIX_ASPECT_RATIO)
-    fs << "aspectRatio" << aspectRatio;
-
-  if (flags != 0)
-  {
-    sprintf(buf, "flags: %s%s%s%s", flags & CV_CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "", flags
-        & CV_CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "", flags & CV_CALIB_FIX_PRINCIPAL_POINT
-        ? "+fix_principal_point" : "", flags & CV_CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "");
-    cvWriteComment(*fs, buf, 0);
-  }
-
-  fs << "flags" << flags;
-
-  fs << "camera_matrix" << cameraMatrix;
-  fs << "distortion_coefficients" << distCoeffs;
-
-  fs << "avg_reprojection_error" << totalAvgErr;
-  if (!reprojErrs.empty())
-    fs << "per_view_reprojection_errors" << Mat(reprojErrs);
-
-  if (!rvecs.empty() && !tvecs.empty())
-  {
-    Mat bigmat(rvecs.size(), 6, CV_32F);
-    for (size_t i = 0; i < rvecs.size(); i++)
-    {
-      Mat r = bigmat(Range(i, i + 1), Range(0, 3));
-      Mat t = bigmat(Range(i, i + 1), Range(3, 6));
-      rvecs[i].copyTo(r);
-      tvecs[i].copyTo(t);
-    }
-    cvWriteComment(*fs, "a set of 6-tuples (rotation vector + translation vector) for each view", 0);
-    fs << "extrinsic_parameters" << bigmat;
-  }
-
-  if (!imagePoints.empty())
-  {
-    Mat imagePtMat(imagePoints.size(), imagePoints[0].size(), CV_32FC2);
-    for (size_t i = 0; i < imagePoints.size(); i++)
-    {
-      Mat r = imagePtMat.row(i).reshape(2, imagePtMat.cols);
-      Mat(imagePoints[i]).copyTo(r);
-    }
-    fs << "image_points" << imagePtMat;
-  }
-}
-void Processor::resetChess()
-{
-
-  imagepoints.clear();
-}
-
-void Processor::calibrate(const char* filename)
-{
-
-  vector<Mat> rvecs, tvecs;
-  vector<float> reprojErrs;
-  double totalAvgErr = 0;
-  int flags = 0;
-  bool writeExtrinsics = true;
-  bool writePoints = true;
-
-  bool ok = runCalibration(imagepoints, imgsize, Size(6, 8), 1.f, 1.f, flags, K, distortion, rvecs, tvecs, reprojErrs,
-                           totalAvgErr);
-
-  if (ok)
-  {
-
-    saveCameraParams(filename, imgsize, Size(6, 8), 1.f, 1.f, flags, K, distortion, writeExtrinsics ? rvecs : vector<
-        Mat> (), writeExtrinsics ? tvecs : vector<Mat> (), writeExtrinsics ? reprojErrs : vector<float> (), writePoints
-        ? imagepoints : vector<vector<Point2f> > (), totalAvgErr);
-  }
-
-}
-
-int Processor::getNumberDetectedChessboards()
-{
-  return imagepoints.size();
-}
diff --git a/android/apps/CVCamera/jni/Processor.h b/android/apps/CVCamera/jni/Processor.h
deleted file mode 100644
index cf61571ab5..0000000000
--- a/android/apps/CVCamera/jni/Processor.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Processor.h
- *
- *  Created on: Jun 13, 2010
- *      Author: ethan
- */
-
-#ifndef PROCESSOR_H_
-#define PROCESSOR_H_
-
-#include <opencv2/core/core.hpp>
-#include <opencv2/features2d/features2d.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/calib3d/calib3d.hpp>
-
-#include <vector>
-
-#include "image_pool.h"
-
-#define DETECT_FAST 0
-#define DETECT_STAR 1
-#define DETECT_SURF 2
-
-class Processor
-{
-public:
-
-  Processor();
-  virtual ~Processor();
-
-  void detectAndDrawFeatures(int idx, image_pool* pool, int feature_type);
-
-  bool detectAndDrawChessboard(int idx, image_pool* pool);
-
-  void resetChess();
-
-  int getNumberDetectedChessboards();
-
-  void calibrate(const char* filename);
-
-  void drawText(int idx, image_pool* pool, const char* text);
-private:
-  cv::StarFeatureDetector stard;
-  cv::FastFeatureDetector fastd;
-  cv::SurfFeatureDetector surfd;
-  std::vector<cv::KeyPoint> keypoints;
-  std::vector<std::vector<cv::Point2f> > imagepoints;
-
-  cv::Mat K;
-  cv::Mat distortion;
-  cv::Size imgsize;
-
-};
-
-#endif /* PROCESSOR_H_ */
diff --git a/android/apps/CVCamera/jni/Processor.i b/android/apps/CVCamera/jni/Processor.i
deleted file mode 100644
index ff66d53070..0000000000
--- a/android/apps/CVCamera/jni/Processor.i
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * include the headers required by the generated cpp code
- */
-%{
-#include "Processor.h"
-#include "image_pool.h"
-using namespace cv;
-%}
-
-
-/**
- * some constants, see Processor.h
- */
-#define DETECT_FAST 0
-#define DETECT_STAR 1
-#define DETECT_SURF 2
-
-//import the android-cv.i file so that swig is aware of all that has been previous defined
-//notice that it is not an include....
-%import "android-cv.i"
-
-//make sure to import the image_pool as it is 
-//referenced by the Processor java generated
-//class
-%typemap(javaimports) Processor "
-import com.opencv.jni.image_pool;// import the image_pool interface for playing nice with
-								 // android-opencv
-
-/** Processor - for processing images that are stored in an image pool
-*/"
-
-class Processor {
-public:
-	Processor();
-	virtual ~Processor();
-
-	
-	
-	void detectAndDrawFeatures(int idx, image_pool* pool, int feature_type);
-
-	bool detectAndDrawChessboard(int idx,image_pool* pool);
-	
-	void resetChess();
-	
-	int getNumberDetectedChessboards();
-	
-	void calibrate(const char* filename);
-	
-	void drawText(int idx, image_pool* pool, const char* text);
-
-};
diff --git a/android/apps/CVCamera/jni/cvcamera.i b/android/apps/CVCamera/jni/cvcamera.i
deleted file mode 100644
index ccca8d91a0..0000000000
--- a/android/apps/CVCamera/jni/cvcamera.i
+++ /dev/null
@@ -1,36 +0,0 @@
-/* File : android-cv.i */
-
-%module cvcamera
-
-
-/*
- * the java import code muse be included for the opencv jni wrappers
- * this means that the android project must reference opencv/android as a project
- * see the default.properties for how this is done
- */
-%pragma(java) jniclassimports=%{
-import com.opencv.jni.*; //import the android-opencv jni wrappers
-%}
-
-%pragma(java) jniclasscode=%{
-	static {
-		try {
-			//load the cvcamera library, make sure that libcvcamera.so is in your <project>/libs/armeabi directory
-			//so that android sdk automatically installs it along with the app.
-			
-			//the android-opencv lib must be loaded first inorder for the cvcamera
-			//lib to be found
-			//check the apk generated, by opening it in an archive manager, to verify that
-			//both these libraries are present
-			System.loadLibrary("android-opencv");
-			System.loadLibrary("cvcamera");
-		} catch (UnsatisfiedLinkError e) {
-			//badness
-			throw e;
-		}
-	}
-
-%}
-
-//include the Processor class swig interface file
-%include "Processor.i"
\ No newline at end of file
diff --git a/android/apps/CVCamera/project_create.sh b/android/apps/CVCamera/project_create.sh
deleted file mode 100755
index ec7672872e..0000000000
--- a/android/apps/CVCamera/project_create.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-android update project --name CVCamera \
---path .
diff --git a/android/apps/CVCamera/res/drawable-ldpi/icon.png b/android/apps/CVCamera/res/drawable-ldpi/icon.png
deleted file mode 100644
index 5e11406cb2..0000000000
Binary files a/android/apps/CVCamera/res/drawable-ldpi/icon.png and /dev/null differ
diff --git a/android/apps/CVCamera/res/drawable-mdpi/icon.png b/android/apps/CVCamera/res/drawable-mdpi/icon.png
deleted file mode 100644
index a591eb892d..0000000000
Binary files a/android/apps/CVCamera/res/drawable-mdpi/icon.png and /dev/null differ
diff --git a/android/apps/CVCamera/res/layout/main.xml b/android/apps/CVCamera/res/layout/main.xml
deleted file mode 100644
index ae6cdd14df..0000000000
--- a/android/apps/CVCamera/res/layout/main.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:orientation="vertical"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    >
-
-</LinearLayout>
diff --git a/android/apps/CVCamera/res/values/strings.xml b/android/apps/CVCamera/res/values/strings.xml
deleted file mode 100644
index 5fe379d698..0000000000
--- a/android/apps/CVCamera/res/values/strings.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    
-    <string name="app_name">CVCamera</string>
-<string name="app_description">app to demo using android camera and passing data to opencv layer.</string>
-<string name="Changes">Release 0.0.1 - first demo of using the OpenCV library with camera data</string>
-</resources>
diff --git a/android/apps/CVCamera/src/com/theveganrobot/cvcamera/CVCamera.java b/android/apps/CVCamera/src/com/theveganrobot/cvcamera/CVCamera.java
deleted file mode 100644
index b1fcbfabc8..0000000000
--- a/android/apps/CVCamera/src/com/theveganrobot/cvcamera/CVCamera.java
+++ /dev/null
@@ -1,505 +0,0 @@
-package com.theveganrobot.cvcamera;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.util.LinkedList;
-import java.util.Scanner;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.app.Dialog;
-import android.app.ProgressDialog;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.content.pm.ActivityInfo;
-import android.os.Bundle;
-import android.os.Environment;
-import android.util.Log;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup.LayoutParams;
-import android.view.Window;
-import android.view.WindowManager;
-import android.widget.Button;
-import android.widget.FrameLayout;
-import android.widget.ImageButton;
-import android.widget.LinearLayout;
-import android.widget.Toast;
-
-import com.opencv.camera.CameraConfig;
-import com.opencv.camera.NativePreviewer;
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.jni.image_pool;
-import com.opencv.opengl.GL2CameraViewer;
-import com.theveganrobot.cvcamera.jni.Processor;
-import com.theveganrobot.cvcamera.jni.cvcamera;
-
-public class CVCamera extends Activity {
-
-	static final int DIALOG_CALIBRATING = 0;
-	static final int DIALOG_CALIBRATION_FILE = 1;
-	private static final int DIALOG_OPENING_TUTORIAL = 2;
-	private static final int DIALOG_TUTORIAL_FAST = 3;
-	private static final int DIALOG_TUTORIAL_SURF = 4;
-	private static final int DIALOG_TUTORIAL_STAR = 5;
-	private static final int DIALOG_TUTORIAL_CHESS = 6;
-	private boolean captureChess;
-
-	ProgressDialog makeCalibDialog() {
-		ProgressDialog progressDialog;
-		progressDialog = new ProgressDialog(this);
-		progressDialog.setMessage("Callibrating. Please wait...");
-		progressDialog.setCancelable(false);
-
-		return progressDialog;
-	}
-
-	void toasts(int id) {
-		switch (id) {
-		case DIALOG_OPENING_TUTORIAL:
-			Toast.makeText(this, "Try clicking the menu for CV options.",
-					Toast.LENGTH_LONG).show();
-			break;
-		case DIALOG_TUTORIAL_FAST:
-			Toast.makeText(this, "Detecting and Displaying FAST features",
-					Toast.LENGTH_LONG).show();
-			break;
-		case DIALOG_TUTORIAL_SURF:
-			Toast.makeText(this, "Detecting and Displaying SURF features",
-					Toast.LENGTH_LONG).show();
-			break;
-		case DIALOG_TUTORIAL_STAR:
-			Toast.makeText(this, "Detecting and Displaying STAR features",
-					Toast.LENGTH_LONG).show();
-			break;
-		case DIALOG_TUTORIAL_CHESS:
-			Toast.makeText(
-					this,
-					"Calibration Mode, Point at a chessboard pattern and press the camera button, space,"
-							+ "or the DPAD to capture.", Toast.LENGTH_LONG)
-					.show();
-			break;
-
-		default:
-			break;
-		}
-
-	}
-
-	@Override
-	protected Dialog onCreateDialog(int id) {
-		Dialog dialog;
-		switch (id) {
-		case DIALOG_CALIBRATING:
-			dialog = makeCalibDialog();
-			break;
-
-		case DIALOG_CALIBRATION_FILE:
-			dialog = makeCalibFileAlert();
-			break;
-		default:
-			dialog = null;
-		}
-		return dialog;
-	}
-
-	private Dialog makeCalibFileAlert() {
-		AlertDialog.Builder builder = new AlertDialog.Builder(this);
-		builder.setMessage(calib_text)
-				.setTitle("camera.yml at " + calib_file_loc)
-				.setCancelable(false)
-				.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
-					public void onClick(DialogInterface dialog, int id) {
-
-					}
-				});
-		AlertDialog alert = builder.create();
-		return alert;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see android.app.Activity#onKeyUp(int, android.view.KeyEvent)
-	 */
-	@Override
-	public boolean onKeyUp(int keyCode, KeyEvent event) {
-
-		switch (keyCode) {
-		case KeyEvent.KEYCODE_CAMERA:
-		case KeyEvent.KEYCODE_SPACE:
-		case KeyEvent.KEYCODE_DPAD_CENTER:
-			captureChess = true;
-			return true;
-
-		default:
-			return super.onKeyUp(keyCode, event);
-		}
-
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * 
-	 * @see android.app.Activity#onKeyLongPress(int, android.view.KeyEvent)
-	 */
-	@Override
-	public boolean onKeyLongPress(int keyCode, KeyEvent event) {
-
-		return super.onKeyLongPress(keyCode, event);
-	}
-
-	/**
-	 * Avoid that the screen get's turned off by the system.
-	 */
-	public void disableScreenTurnOff() {
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
-				WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-	}
-
-	/**
-	 * Set's the orientation to landscape, as this is needed by AndAR.
-	 */
-	public void setOrientation() {
-		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-	}
-
-	/**
-	 * Maximize the application.
-	 */
-	public void setFullscreen() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-				WindowManager.LayoutParams.FLAG_FULLSCREEN);
-	}
-
-	public void setNoTitle() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-	}
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		menu.add("FAST");
-		menu.add("STAR");
-		menu.add("SURF");
-		menu.add("Chess");
-		menu.add("Settings");
-		return true;
-	}
-
-	private NativePreviewer mPreview;
-	private GL2CameraViewer glview;
-
-	@Override
-	public boolean onOptionsItemSelected(MenuItem item) {
-		LinkedList<PoolCallback> defaultcallbackstack = new LinkedList<PoolCallback>();
-		defaultcallbackstack.addFirst(glview.getDrawCallback());
-		if (item.getTitle().equals("FAST")) {
-
-			defaultcallbackstack.addFirst(new FastProcessor());
-			toasts(DIALOG_TUTORIAL_FAST);
-		}
-
-		else if (item.getTitle().equals("Chess")) {
-
-			defaultcallbackstack.addFirst(new CalibrationProcessor());
-			toasts(DIALOG_TUTORIAL_CHESS);
-
-		}
-
-		else if (item.getTitle().equals("STAR")) {
-
-			defaultcallbackstack.addFirst(new STARProcessor());
-			toasts(DIALOG_TUTORIAL_STAR);
-
-		}
-
-		else if (item.getTitle().equals("SURF")) {
-
-			defaultcallbackstack.addFirst(new SURFProcessor());
-			toasts(DIALOG_TUTORIAL_SURF);
-
-		}
-
-		else if (item.getTitle().equals("Settings")) {
-
-			Intent intent = new Intent(this,CameraConfig.class);
-			startActivity(intent);
-		}
-
-		mPreview.addCallbackStack(defaultcallbackstack);
-		
-		return true;
-	}
-
-	@Override
-	public void onOptionsMenuClosed(Menu menu) {
-		// TODO Auto-generated method stub
-		super.onOptionsMenuClosed(menu);
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-
-		setFullscreen();
-		disableScreenTurnOff();
-
-		FrameLayout frame = new FrameLayout(this);
-
-		// Create our Preview view and set it as the content of our activity.
-		mPreview = new NativePreviewer(getApplication(), 640, 480);
-
-		LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT,
-				LayoutParams.WRAP_CONTENT);
-		params.height = getWindowManager().getDefaultDisplay().getHeight();
-		params.width = (int) (params.height * 4.0 / 2.88);
-
-		LinearLayout vidlay = new LinearLayout(getApplication());
-
-		vidlay.setGravity(Gravity.CENTER);
-		vidlay.addView(mPreview, params);
-		frame.addView(vidlay);
-
-		// make the glview overlay ontop of video preview
-		mPreview.setZOrderMediaOverlay(false);
-
-		glview = new GL2CameraViewer(getApplication(), false, 0, 0);
-		glview.setZOrderMediaOverlay(true);
-
-		LinearLayout gllay = new LinearLayout(getApplication());
-
-		gllay.setGravity(Gravity.CENTER);
-		gllay.addView(glview, params);
-		frame.addView(gllay);
-
-		ImageButton capture_button = new ImageButton(getApplicationContext());
-		capture_button.setImageDrawable(getResources().getDrawable(
-				android.R.drawable.ic_menu_camera));
-		capture_button.setLayoutParams(new LayoutParams(
-				LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
-		capture_button.setOnClickListener(new View.OnClickListener() {
-
-			@Override
-			public void onClick(View v) {
-				captureChess = true;
-
-			}
-		});
-
-		LinearLayout buttons = new LinearLayout(getApplicationContext());
-		buttons.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT,
-				LayoutParams.WRAP_CONTENT));
-
-		buttons.addView(capture_button);
-
-		Button focus_button = new Button(getApplicationContext());
-		focus_button.setLayoutParams(new LayoutParams(
-				LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
-		focus_button.setText("Focus");
-		focus_button.setOnClickListener(new View.OnClickListener() {
-
-			@Override
-			public void onClick(View v) {
-				mPreview.postautofocus(100);
-			}
-		});
-		buttons.addView(focus_button);
-
-		frame.addView(buttons);
-		setContentView(frame);
-		toasts(DIALOG_OPENING_TUTORIAL);
-	}
-
-	@Override
-	public boolean onTrackballEvent(MotionEvent event) {
-		if (event.getAction() == MotionEvent.ACTION_UP) {
-			captureChess = true;
-			return true;
-		}
-		return super.onTrackballEvent(event);
-	}
-
-	@Override
-	protected void onPause() {
-		super.onPause();
-
-		// clears the callback stack
-		mPreview.onPause();
-
-		glview.onPause();
-
-	}
-
-	@Override
-	protected void onResume() {
-		super.onResume();
-		glview.onResume();
-		mPreview.setParamsFromPrefs(getApplicationContext());
-		// add an initiall callback stack to the preview on resume...
-		// this one will just draw the frames to opengl
-		LinkedList<NativeProcessor.PoolCallback> cbstack = new LinkedList<PoolCallback>();
-		cbstack.add(glview.getDrawCallback());
-		mPreview.addCallbackStack(cbstack);
-		mPreview.onResume();
-
-	}
-
-	// final processor so taht these processor callbacks can access it
-	final Processor processor = new Processor();
-
-	class FastProcessor implements NativeProcessor.PoolCallback {
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-			processor.detectAndDrawFeatures(idx, pool, cvcamera.DETECT_FAST);
-
-		}
-
-	}
-
-	class STARProcessor implements NativeProcessor.PoolCallback {
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-			processor.detectAndDrawFeatures(idx, pool, cvcamera.DETECT_STAR);
-
-		}
-
-	}
-
-	class SURFProcessor implements NativeProcessor.PoolCallback {
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-			processor.detectAndDrawFeatures(idx, pool, cvcamera.DETECT_SURF);
-
-		}
-
-	}
-
-	String calib_text = null;
-	String calib_file_loc = null;
-
-	class CalibrationProcessor implements NativeProcessor.PoolCallback {
-
-		boolean calibrated = false;
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-
-			if (calibrated) {
-				processor.drawText(idx, pool, "Calibrated successfully");
-				return;
-			}
-			if (processor.getNumberDetectedChessboards() == 10) {
-
-				File opencvdir = new File(
-						Environment.getExternalStorageDirectory(), "opencv");
-				if (!opencvdir.exists()) {
-					opencvdir.mkdir();
-				}
-				File calibfile = new File(opencvdir, "camera.yml");
-
-				calib_file_loc = calibfile.getAbsolutePath();
-				processor.calibrate(calibfile.getAbsolutePath());
-				Log.i("chessboard", "calibrated");
-				calibrated = true;
-				processor.resetChess();
-				runOnUiThread(new Runnable() {
-
-					@Override
-					public void run() {
-						removeDialog(DIALOG_CALIBRATING);
-
-					}
-				});
-
-				try {
-
-					StringBuilder text = new StringBuilder();
-					String NL = System.getProperty("line.separator");
-					Scanner scanner = new Scanner(calibfile);
-
-					try {
-						while (scanner.hasNextLine()) {
-							text.append(scanner.nextLine() + NL);
-						}
-					} finally {
-						scanner.close();
-					}
-
-					calib_text = text.toString();
-
-					runOnUiThread(new Runnable() {
-
-						@Override
-						public void run() {
-							showDialog(DIALOG_CALIBRATION_FILE);
-
-						}
-					});
-
-				} catch (FileNotFoundException e) {
-					// TODO Auto-generated catch block
-					e.printStackTrace();
-				}
-
-			} else if (captureChess
-					&& processor.detectAndDrawChessboard(idx, pool)) {
-
-				runOnUiThread(new Runnable() {
-
-					String numchess = String.valueOf(processor
-							.getNumberDetectedChessboards());
-
-					@Override
-					public void run() {
-						Toast.makeText(CVCamera.this,
-								"Detected " + numchess + " of 10 chessboards",
-								Toast.LENGTH_SHORT).show();
-
-					}
-				});
-				Log.i("cvcamera",
-						"detected a chessboard, n chess boards found: "
-								+ String.valueOf(processor
-										.getNumberDetectedChessboards()));
-
-			}
-
-			captureChess = false;
-
-			if (processor.getNumberDetectedChessboards() == 10) {
-				runOnUiThread(new Runnable() {
-
-					@Override
-					public void run() {
-						showDialog(DIALOG_CALIBRATING);
-
-					}
-				});
-
-				processor.drawText(idx, pool, "Calibrating, please wait.");
-			}
-			if (processor.getNumberDetectedChessboards() < 10) {
-
-				processor.drawText(idx, pool,
-						"found " + processor.getNumberDetectedChessboards()
-								+ "/10 chessboards");
-			}
-
-		}
-
-	}
-
-}
diff --git a/android/apps/CVCamera/uninstall.phone.sh b/android/apps/CVCamera/uninstall.phone.sh
deleted file mode 100755
index 06b78cabec..0000000000
--- a/android/apps/CVCamera/uninstall.phone.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-echo uninstalling CVCamera from phone
-adb uninstall com.theveganrobot.cvcamera
diff --git a/android/apps/Calibration/AndroidManifest.xml b/android/apps/Calibration/AndroidManifest.xml
deleted file mode 100644
index 295dc9d432..0000000000
--- a/android/apps/Calibration/AndroidManifest.xml
+++ /dev/null
@@ -1,46 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.opencv.calibration" android:versionCode="1"
-	android:versionName="1.0">
-
-	<application android:debuggable="true" android:icon="@drawable/icon"
-		android:label="@string/app_name">
-
-		<activity android:name=".Calibration" android:label="@string/app_name"
-			android:screenOrientation="landscape"  
-			android:configChanges="orientation|keyboardHidden|keyboard">
-			<intent-filter>
-				<!-- <action android:name="android.intent.action.MAIN" /> -->
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-
-		</activity>
-		<!--
-			These activities are defined in the android-jni library, and just reused here
-		-->
-		<activity android:name="com.opencv.calibration.ChessBoardChooser" android:label="@string/app_name"
-			android:screenOrientation="landscape" 
-			android:configChanges="orientation|keyboardHidden|keyboard">
-		</activity>
-		
-		<activity android:name="com.opencv.camera.CameraConfig" android:label="@string/app_name"
-			android:screenOrientation="landscape" 
-			android:configChanges="orientation|keyboardHidden|keyboard">
-		</activity>
-		
-		<activity android:name="com.opencv.calibration.CalibrationViewer"  android:label="@string/app_name"/>
-
-		<service android:name="com.opencv.calibration.services.CalibrationService"></service>
-
-	</application>
-
-	<uses-sdk android:minSdkVersion="7" />
-
-	<uses-feature android:glEsVersion="0x00020000" />
-
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
-
-
-</manifest> 
diff --git a/android/apps/Calibration/README.txt b/android/apps/Calibration/README.txt
deleted file mode 100644
index 17e3222933..0000000000
--- a/android/apps/Calibration/README.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-to build completeley from command line:
-sh project_create.sh
-ant debug
-ant install
-
-That assumes that you have already build the opencv/android/android-jni project
-
-If you're in eclipse, try to create a new android project from existing sources.
-Make sure that you also have the android-jni project open in eclipse is this is the case
-or the android library dependency will give you errors.
\ No newline at end of file
diff --git a/android/apps/Calibration/artwork/icon.xcf b/android/apps/Calibration/artwork/icon.xcf
deleted file mode 100644
index aa7bb992b0..0000000000
Binary files a/android/apps/Calibration/artwork/icon.xcf and /dev/null differ
diff --git a/android/apps/Calibration/default.properties b/android/apps/Calibration/default.properties
deleted file mode 100644
index 7f801f9c35..0000000000
--- a/android/apps/Calibration/default.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
-# This file must be checked in Version Control Systems.
-# 
-# To customize properties used by the Ant build system use,
-# "build.properties", and override values to adapt the script to your
-# project structure.
-
-android.library.reference.1=../../android-opencv/
-# Project target.
-target=android-7
diff --git a/android/apps/Calibration/project_create.sh b/android/apps/Calibration/project_create.sh
deleted file mode 100755
index f8c9c51ff2..0000000000
--- a/android/apps/Calibration/project_create.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-android update project --name Calibration \
---path .
diff --git a/android/apps/Calibration/res/drawable-hdpi/icon.png b/android/apps/Calibration/res/drawable-hdpi/icon.png
deleted file mode 100644
index ab9f932889..0000000000
Binary files a/android/apps/Calibration/res/drawable-hdpi/icon.png and /dev/null differ
diff --git a/android/apps/Calibration/res/drawable-ldpi/icon.png b/android/apps/Calibration/res/drawable-ldpi/icon.png
deleted file mode 100644
index ab9f932889..0000000000
Binary files a/android/apps/Calibration/res/drawable-ldpi/icon.png and /dev/null differ
diff --git a/android/apps/Calibration/res/drawable-mdpi/cameraback.jpg b/android/apps/Calibration/res/drawable-mdpi/cameraback.jpg
deleted file mode 100644
index b53ffd4891..0000000000
Binary files a/android/apps/Calibration/res/drawable-mdpi/cameraback.jpg and /dev/null differ
diff --git a/android/apps/Calibration/res/drawable-mdpi/icon.png b/android/apps/Calibration/res/drawable-mdpi/icon.png
deleted file mode 100644
index ab9f932889..0000000000
Binary files a/android/apps/Calibration/res/drawable-mdpi/icon.png and /dev/null differ
diff --git a/android/apps/Calibration/res/drawable-mdpi/patternicon.png b/android/apps/Calibration/res/drawable-mdpi/patternicon.png
deleted file mode 100644
index 879044ad09..0000000000
Binary files a/android/apps/Calibration/res/drawable-mdpi/patternicon.png and /dev/null differ
diff --git a/android/apps/Calibration/res/layout/calib_camera.xml b/android/apps/Calibration/res/layout/calib_camera.xml
deleted file mode 100644
index 35dc96f06c..0000000000
--- a/android/apps/Calibration/res/layout/calib_camera.xml
+++ /dev/null
@@ -1,45 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-	xmlns:opencv="http://schemas.android.com/apk/res/com.opencv"
-	android:layout_width="fill_parent" android:layout_height="fill_parent"
-	android:background="@drawable/cameraback">
-	<!--<com.opencv.camera.NativePreviewer -->
-	<!-- <SurfaceView -->
-
-	<com.opencv.camera.NativePreviewer		
-		android:id="@+id/nativepreviewer" android:layout_width="400dip"
-		android:layout_height="300dip" android:layout_alignParentLeft="true"
-		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
-		android:layout_marginRight="20dip"
-		/>
-	<LinearLayout android:id="@+id/glview_layout"
-
-		android:layout_width="400dip" android:layout_height="300dip"
-		android:layout_alignParentLeft="true" android:layout_margin="20dip"
-		android:gravity="center_horizontal|center_vertical"
-		android:layout_marginRight="20dip">
-	</LinearLayout>
-	<LinearLayout android:layout_width="wrap_content"
-		android:layout_height="fill_parent" android:orientation="vertical"
-		android:layout_margin="20dip" android:gravity="center_horizontal|center_vertical"
-		android:layout_alignParentRight="true">
-
-
-		<ImageButton android:src="@android:drawable/ic_menu_camera"
-			android:id="@+id/capture" android:layout_width="60dip"
-			android:layout_height="60dip"></ImageButton>
-		<ImageButton android:src="@android:drawable/ic_menu_save"
-			android:id="@+id/calibrate" android:layout_width="60dip"
-			android:layout_height="60dip"></ImageButton>
-		<TextView android:id="@+id/numberpatterns"
-			android:layout_width="wrap_content" android:layout_height="wrap_content"
-			android:padding="10dip" android:background="@android:color/white"
-			android:text="0" />
-
-
-	</LinearLayout>
-
-
-
-
-</RelativeLayout>
diff --git a/android/apps/Calibration/res/menu/calibrationmenu.xml b/android/apps/Calibration/res/menu/calibrationmenu.xml
deleted file mode 100644
index c157df9223..0000000000
--- a/android/apps/Calibration/res/menu/calibrationmenu.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
-	<item android:id="@+id/calibrate" android:titleCondensed="Calib"
-		android:title="Calibrate"></item>
-	<item android:id="@+id/patternsize" android:titleCondensed="Size"
-		android:title="@string/patternsize" android:icon="@drawable/patternicon"></item>
-
-
-<item android:id="@+id/settings" android:title="Settings" android:icon="@android:drawable/ic_menu_preferences"></item>
-<item android:id="@+id/help" android:title="Help" android:icon="@android:drawable/ic_menu_help"></item>
-</menu>
diff --git a/android/apps/Calibration/res/values/color.xml b/android/apps/Calibration/res/values/color.xml
deleted file mode 100644
index e33983712b..0000000000
--- a/android/apps/Calibration/res/values/color.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<color name="good_color">#00ff00</color>
-<color name="bad_color">#FF0000</color>
-</resources>
diff --git a/android/apps/Calibration/res/values/strings.xml b/android/apps/Calibration/res/values/strings.xml
deleted file mode 100644
index 9e57fdef8c..0000000000
--- a/android/apps/Calibration/res/values/strings.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-   	<string name="calibfile">/opencv/camera.yml</string>
-	<string name="sdcarddir">/opencv</string>
-	
-	<string name="calibration_service_started">Calibration calculations have started...</string>
-	<string name="calibration_service_stopped">Calibration calculations has stopped.</string>
-	<string name="calibration_service_finished">Calibration finished, you camera is calibrated.</string>
-	<string name="calibration_service_label">Calibration</string>
-	<string name="calibration_not_enough">Please capture atleast 10 images of the pattern!</string>	
-	<string name="sdcard_error_msg"> Please make sure that you\'re sdcard is not mounted to you\'re computer, and that you have an sdcard that is writable on your device.</string>
-
-</resources>
diff --git a/android/apps/Calibration/src/com/opencv/calibration/Calibration.java b/android/apps/Calibration/src/com/opencv/calibration/Calibration.java
deleted file mode 100644
index 64217fb610..0000000000
--- a/android/apps/Calibration/src/com/opencv/calibration/Calibration.java
+++ /dev/null
@@ -1,325 +0,0 @@
-package com.opencv.calibration;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.LinkedList;
-
-import android.app.Activity;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.Intent;
-import android.content.ServiceConnection;
-import android.content.pm.ActivityInfo;
-import android.os.Bundle;
-import android.os.IBinder;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.Window;
-import android.view.WindowManager;
-import android.widget.ImageButton;
-import android.widget.LinearLayout;
-import android.widget.TextView;
-import android.widget.Toast;
-
-import com.opencv.calibration.Calibrator.CalibrationCallback;
-import com.opencv.calibration.services.CalibrationService;
-import com.opencv.camera.CameraConfig;
-import com.opencv.camera.NativePreviewer;
-import com.opencv.camera.NativeProcessor;
-import com.opencv.misc.SDCardChecker;
-import com.opencv.opengl.GL2CameraViewer;
-
-public class Calibration extends Activity implements CalibrationCallback {
-	private NativePreviewer mPreview;
-
-	private GL2CameraViewer glview;
-	private Calibrator calibrator;
-
-	@Override
-	public boolean onKeyUp(int keyCode, KeyEvent event) {
-
-		switch (keyCode) {
-		case KeyEvent.KEYCODE_CAMERA:
-		case KeyEvent.KEYCODE_SPACE:
-		case KeyEvent.KEYCODE_DPAD_CENTER:
-			calibrator.queueChessCapture();
-			return true;
-		default:
-			return super.onKeyUp(keyCode, event);
-		}
-
-	}
-
-	@Override
-	public boolean onTrackballEvent(MotionEvent event) {
-		if (event.getAction() == MotionEvent.ACTION_UP) {
-			calibrator.queueChessCapture();
-			return true;
-		}
-		return super.onTrackballEvent(event);
-	}
-
-	/**
-	 * Avoid that the screen get's turned off by the system.
-	 */
-	public void disableScreenTurnOff() {
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
-				WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-	}
-
-	/**
-	 * Set's the orientation to landscape, as this is needed by AndAR.
-	 */
-	public void setOrientation() {
-		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-	}
-
-	/**
-	 * Maximize the application.
-	 */
-	public void setFullscreen() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-				WindowManager.LayoutParams.FLAG_FULLSCREEN);
-	}
-
-	public void setNoTitle() {
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-	}
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		MenuInflater inflater = getMenuInflater();
-		inflater.inflate(R.menu.calibrationmenu, menu);
-		return true;
-	}
-
-	@Override
-	public boolean onOptionsItemSelected(MenuItem item) {
-		switch (item.getItemId()) {
-		case R.id.patternsize: {
-			Intent sizer = new Intent(getApplicationContext(),
-					ChessBoardChooser.class);
-			startActivity(sizer);
-		}
-			break;
-		case R.id.help:
-			help();
-			break;
-		case R.id.calibrate:
-			calibrate();
-			break;
-		case R.id.settings:
-			Intent configurer = new Intent(getApplicationContext(),
-					CameraConfig.class);
-			startActivity(configurer);
-			
-		}
-
-		return true;
-
-	}
-
-	private void help() {
-		// TODO Auto-generated method stub
-		
-	}
-
-	@Override
-	public void onOptionsMenuClosed(Menu menu) {
-		// TODO Auto-generated method stub
-		super.onOptionsMenuClosed(menu);
-	}
-
-	private ServiceConnection mConnection = new ServiceConnection() {
-
-		@Override
-		public void onServiceDisconnected(ComponentName name) {
-
-		}
-
-		@Override
-		public void onServiceConnected(ComponentName name, IBinder service) {
-
-			CalibrationService calibservice = ((CalibrationService.CalibrationServiceBinder) service)
-					.getService();
-			if (!SDCardChecker.CheckStorage(Calibration.this))
-				return;
-			SDCardChecker.MakeDataDir(Calibration.this);
-
-			File calibfile = SDCardChecker.getFile(calibservice,
-					R.string.calibfile);
-			try {
-
-				Calibrator tcalib = calibrator;
-				calibrator = new Calibrator(Calibration.this);
-				setCallbackStack();
-				calibservice.startCalibrating(Calibration.class, R.drawable.icon,tcalib, calibfile);
-			} catch (IOException e) {
-				e.printStackTrace();
-			}
-
-			// Tell the user about this for our demo.
-			Toast.makeText(Calibration.this,
-					"Starting calibration in the background.",
-					Toast.LENGTH_SHORT).show();
-			unbindService(this);
-		}
-
-	};
-
-	public static File getCalibrationFile(Context ctx) {
-		return SDCardChecker.getFile(ctx, R.string.calibfile);
-	}
-
-	void doBindCalibService() {
-		// Establish a connection with the service. We use an explicit
-		// class name because we want a specific service implementation that
-		// we know will be running in our own process (and thus won't be
-		// supporting component replacement by other applications).
-		bindService(new Intent(Calibration.this, CalibrationService.class),
-				mConnection, Context.BIND_AUTO_CREATE);
-	}
-
-	void calibrate() {
-		if (calibrator.getNumberPatternsDetected() < 3) {
-			Toast.makeText(this, getText(R.string.calibration_not_enough),
-					Toast.LENGTH_LONG).show();
-			return;
-		}
-		Intent calibservice = new Intent(Calibration.this,
-				CalibrationService.class);
-		startService(calibservice);
-		doBindCalibService();
-
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-
-		setFullscreen();
-		disableScreenTurnOff();
-		setContentView(R.layout.calib_camera);
-		mPreview = (NativePreviewer) findViewById(R.id.nativepreviewer);
-		mPreview.setPreviewSize(800, 400);
-		mPreview.setGrayscale(true);
-		LinearLayout glview_layout = (LinearLayout) findViewById(R.id.glview_layout);
-		glview = new GL2CameraViewer(getApplication(), false, 0, 0);
-		glview_layout.addView(glview);
-		calibrator = new Calibrator(this);
-
-		ImageButton capturebutton = (ImageButton) findViewById(R.id.capture);
-		capturebutton.setOnClickListener(new View.OnClickListener() {
-			@Override
-			public void onClick(View v) {
-				calibrator.queueChessCapture();
-
-			}
-		});
-		ImageButton calibbutton = (ImageButton) findViewById(R.id.calibrate);
-		calibbutton.setOnClickListener(new View.OnClickListener() {
-			@Override
-			public void onClick(View v) {
-				calibrate();
-			}
-		});
-	}
-
-	@Override
-	protected void onDestroy() {
-		super.onDestroy();
-	}
-
-	@Override
-	protected void onPause() {
-		super.onPause();
-
-		mPreview.onPause();
-
-		glview.onPause();
-
-	}
-
-	protected void setCallbackStack() {
-		calibrator.setPatternSize(ChessBoardChooser.getPatternSize(this));
-
-		LinkedList<NativeProcessor.PoolCallback> callbackstack = new LinkedList<NativeProcessor.PoolCallback>();
-		callbackstack.add(calibrator);
-		callbackstack.add(glview.getDrawCallback());
-		mPreview.addCallbackStack(callbackstack);
-		updateNumber(calibrator);
-	}
-
-	@Override
-	protected void onResume() {
-		super.onResume();
-		int size[] ={0,0};
-		CameraConfig.readImageSize(getApplicationContext(), size);
-		int mode = CameraConfig.readCameraMode(getApplicationContext());
-		mPreview.setPreviewSize(size[0], size[1]);
-		mPreview.setGrayscale(mode == CameraConfig.CAMERA_MODE_BW ? true : false);
-		
-		glview.onResume();
-		mPreview.onResume();
-		setCallbackStack();
-
-	}
-
-	void updateNumber(Calibrator calibrator) {
-		TextView numbertext = (TextView) findViewById(R.id.numberpatterns);
-		int numdetectd = calibrator.getNumberPatternsDetected();
-		if (numdetectd > 2) {
-			numbertext
-					.setTextColor(getResources().getColor(R.color.good_color));
-
-		} else
-			numbertext.setTextColor(getResources().getColor(R.color.bad_color));
-
-		numbertext.setText(String.valueOf(numdetectd));
-
-	}
-
-	@Override
-	public void onFoundChessboard(final Calibrator calibrator) {
-		runOnUiThread(new Runnable() {
-
-			@Override
-			public void run() {
-				Toast.makeText(Calibration.this,
-						"Captured a calibration pattern!", Toast.LENGTH_SHORT)
-						.show();
-				updateNumber(calibrator);
-
-			}
-		});
-
-	}
-
-	@Override
-	public void onDoneCalibration(Calibrator calibration, File calibfile) {
-
-	}
-
-	@Override
-	public void onFailedChessboard(final Calibrator calibrator) {
-		runOnUiThread(new Runnable() {
-
-			@Override
-			public void run() {
-				Toast.makeText(
-						Calibration.this,
-						"No pattern found.  Make sure its the right dimensions, and close enough...",
-						Toast.LENGTH_LONG).show();
-				updateNumber(calibrator);
-
-			}
-		});
-
-	}
-
-}
\ No newline at end of file
diff --git a/android/apps/Calibration/src/com/opencv/misc/SDCardChecker.java b/android/apps/Calibration/src/com/opencv/misc/SDCardChecker.java
deleted file mode 100644
index 1a7d2b7e2c..0000000000
--- a/android/apps/Calibration/src/com/opencv/misc/SDCardChecker.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package com.opencv.misc;
-
-import java.io.File;
-
-import android.content.Context;
-import android.os.Environment;
-import android.widget.Toast;
-
-import com.opencv.calibration.R;
-
-public class SDCardChecker {
-
-	public static File createThumb(Context ctx, File workingDir) {
-		return new File(workingDir, "thumb.jpg");
-	}
-
-	public static File getDir(Context ctx, String relativename) {
-		return new File(Environment.getExternalStorageDirectory()
-				+ relativename);
-	}
-
-	public static File getDir(Context ctx, int id) {
-		return new File(Environment.getExternalStorageDirectory()
-				+ ctx.getResources().getString(id));
-	}
-
-	public static File getFile(Context ctx, int id) {
-		return new File(Environment.getExternalStorageDirectory()
-				+ ctx.getResources().getString(id));
-	}
-
-	public static void MakeDataDir(Context ctx) {
-		File dir = getDir(ctx, R.string.sdcarddir);
-		dir.mkdirs();
-	}
-
-	public static boolean CheckStorage(Context ctx) {
-		boolean mExternalStorageAvailable = false;
-		boolean mExternalStorageWriteable = false;
-		String state = Environment.getExternalStorageState();
-
-		if (Environment.MEDIA_MOUNTED.equals(state)) {
-			// We can read and write the media
-			mExternalStorageAvailable = mExternalStorageWriteable = true;
-		} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
-			// We can only read the media
-			mExternalStorageAvailable = true;
-			mExternalStorageWriteable = false;
-		} else {
-			// Something else is wrong. It may be one of many other states, but
-			// all we need
-			// to know is we can neither read nor write
-			mExternalStorageAvailable = mExternalStorageWriteable = false;
-		}
-		boolean goodmount = mExternalStorageAvailable
-				&& mExternalStorageWriteable;
-		if (!goodmount) {
-			Toast.makeText(ctx, ctx.getString(R.string.sdcard_error_msg),
-					Toast.LENGTH_LONG).show();
-		}
-		return goodmount;
-	}
-
-}
diff --git a/android/apps/HelloAndroid/cmake_android.cmd b/android/apps/HelloAndroid/cmake_android.cmd
deleted file mode 100644
index e43e39016b..0000000000
--- a/android/apps/HelloAndroid/cmake_android.cmd
+++ /dev/null
@@ -1,9 +0,0 @@
-@ECHO OFF
-SETLOCAL
-PUSHD %~dp0
-SET PROJECT_NAME=HelloAndroid
-SET BUILD_DIR=build_armeabi
-SET ARM_TARGET=armeabi
-CALL ..\..\scripts\build.cmd %*
-POPD
-ENDLOCAL
\ No newline at end of file
diff --git a/android/apps/OpenCV_SAMPLE/AndroidManifest.xml b/android/apps/OpenCV_SAMPLE/AndroidManifest.xml
deleted file mode 100644
index c129d813a6..0000000000
--- a/android/apps/OpenCV_SAMPLE/AndroidManifest.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.OpenCV_SAMPLE" android:versionCode="1"
-	android:versionName="1.0">
-	<application android:label="@string/app_name"
-		android:debuggable="true" android:icon="@drawable/icon">
-		<activity android:name=".OpenCV_SAMPLE" android:label="@string/app_name"
-			android:screenOrientation="landscape" android:configChanges="orientation|keyboardHidden|keyboard">
-			<intent-filter>
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-		</activity>
-		<!-- These activities are defined in the android-opencv library, and just 
-			reused here -->
-		<activity android:name="com.opencv.camera.CameraConfig"
-			android:label="@string/app_name" android:screenOrientation="landscape"
-			android:configChanges="orientation|keyboardHidden|keyboard">
-		</activity>
-	</application>
-
-	<uses-sdk android:minSdkVersion="7" />
-
-	<!-- set the opengl version -->
-	<uses-feature android:glEsVersion="0x00020000" />
-	<!-- use the camera -->
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-
-</manifest> 
\ No newline at end of file
diff --git a/android/apps/OpenCV_SAMPLE/CMakeLists.txt b/android/apps/OpenCV_SAMPLE/CMakeLists.txt
deleted file mode 100644
index 954ba5b963..0000000000
--- a/android/apps/OpenCV_SAMPLE/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-
-project(OpenCV_SAMPLE)
-
-add_subdirectory(jni)
diff --git a/android/apps/OpenCV_SAMPLE/cmake_android.cmd b/android/apps/OpenCV_SAMPLE/cmake_android.cmd
deleted file mode 100644
index ce41d62b7c..0000000000
--- a/android/apps/OpenCV_SAMPLE/cmake_android.cmd
+++ /dev/null
@@ -1,7 +0,0 @@
-@ECHO OFF
-SETLOCAL
-PUSHD %~dp0
-SET PROJECT_NAME=OpenCV_SAMPLE
-CALL ..\..\scripts\build.cmd %*
-POPD
-ENDLOCAL
\ No newline at end of file
diff --git a/android/apps/OpenCV_SAMPLE/cmake_android_neon.sh b/android/apps/OpenCV_SAMPLE/cmake_android_neon.sh
deleted file mode 100644
index 66a680e598..0000000000
--- a/android/apps/OpenCV_SAMPLE/cmake_android_neon.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-mkdir build_neon
-cd build_neon
-cmake -DOpenCV_DIR=../../../build_neon -DAndroidOpenCV_DIR=../../../android-opencv/build_neon -DARM_TARGETS="armeabi-v7a with NEON" -DCMAKE_TOOLCHAIN_FILE=$ANDTOOLCHAIN ..
-
diff --git a/android/apps/OpenCV_SAMPLE/default.properties b/android/apps/OpenCV_SAMPLE/default.properties
deleted file mode 100644
index 5d6911a8a9..0000000000
--- a/android/apps/OpenCV_SAMPLE/default.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-#
-# This file must be checked in Version Control Systems.
-#
-# To customize properties used by the Ant build system use,
-# "build.properties", and override values to adapt the script to your
-# project structure.
-
-# Project target.
-target=android-7
-android.library.reference.1=../../android-opencv/
diff --git a/android/apps/OpenCV_SAMPLE/jni/CMakeLists.txt b/android/apps/OpenCV_SAMPLE/jni/CMakeLists.txt
deleted file mode 100644
index 823101c664..0000000000
--- a/android/apps/OpenCV_SAMPLE/jni/CMakeLists.txt
+++ /dev/null
@@ -1,68 +0,0 @@
-#########################################################
-# Find opencv and android-opencv
-#########################################################
-
-set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../../build 
-    CACHE PATH "The path where you built opencv for android")
-set(AndroidOpenCV_DIR ${CMAKE_SOURCE_DIR}/../../android-opencv/build 
-    CACHE PATH "The path where you built android-opencv")
-
-find_package(OpenCV REQUIRED)
-FIND_PACKAGE(AndroidOpenCV REQUIRED )
-
-#########################################################
-#c flags, included, and lib dependencies
-#########################################################
-
-#notice the "recycling" of CMAKE_C_FLAGS
-#this is necessary to pick up android flags
-set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -fPIC" )
-
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-
-set( LIBRARY_DEPS ${AndroidOpenCV_LIBS} ${OpenCV_LIBS} )
-if(ANDROID)
-  set( LIBRARY_DEPS ${LIBRARY_DEPS} log dl)
-endif(ANDROID)
-
-#########################################################
-#SWIG STUFF
-#########################################################
-#the java package to place swig generated java files in
-set(MY_PACKAGE com.OpenCV_SAMPLE.jni )
-set(MY_MODULE OpenCV_SAMPLE )
-set(MY_SWIG 
-    OpenCV_SAMPLE.i #swig file
-    )
-set(MY_SRCS
-    cvsample.cpp #cpp files can be compiled to
-    )
-
-if(NOT ANDROID)
-  #non android swig and jni
-  #jni is available by default on android
-  find_package(JNI REQUIRED)
-  include_directories(${JNI_INCLUDE_DIRS})
-  FIND_PACKAGE(SWIG)
-endif()
-
-INCLUDE(${SWIG_USE_FILE}) #on android this is found by the cmake toolchain
-
-if(ANDROID)
-  #this will set the output path for the java package
-  #and properly create the package declarations in generated java sources
-  SET_SWIG_JAVA_PACKAGE( ${MY_PACKAGE} ) #defined in the android toolchain
-endif(ANDROID)
-
-#this add's the swig path for the opencv wrappers
-SET(CMAKE_SWIG_FLAGS ${CMAKE_SWIG_FLAGS} "-I${AndroidOpenCV_SWIG_DIR}" )
-
-SET_SOURCE_FILES_PROPERTIES(${MY_SWIG} PROPERTIES CPLUSPLUS ON)
-
-#add the swig module, giving it the name, java, and then all of the source files
-SWIG_ADD_MODULE(${MY_MODULE} java 
-                ${MY_SWIG}
-                ${MY_SRCS}
-                )
-#link the module like any other   
-target_link_libraries(${MY_MODULE} ${LIBRARY_DEPS} )
diff --git a/android/apps/OpenCV_SAMPLE/jni/OpenCV_SAMPLE.i b/android/apps/OpenCV_SAMPLE/jni/OpenCV_SAMPLE.i
deleted file mode 100644
index 93b6c89466..0000000000
--- a/android/apps/OpenCV_SAMPLE/jni/OpenCV_SAMPLE.i
+++ /dev/null
@@ -1,48 +0,0 @@
-/* File : foobar.i */
-%module OpenCV_SAMPLE
-
-/*
- * the java import code muse be included for the opencv jni wrappers
- * this means that the android project must reference opencv/android as a project
- * see the default.properties for how this is done
- */
-%pragma(java) jniclassimports=%{
-import com.opencv.jni.*; //import the android-opencv jni wrappers
-%}
-
-%pragma(java) jniclasscode=%{
-  static {
-    try {
-        //load up our shared libraries
-        System.loadLibrary("android-opencv");
-        System.loadLibrary("OpenCV_SAMPLE");
-      } catch (UnsatisfiedLinkError e) {
-        //badness
-        throw e;
-    }
-  }
-
-%}
-
-//import the android-cv.i file so that swig is aware of all that has been previous defined
-//notice that it is not an include....
-%import "android-cv.i"
-
-%{
-#include "cvsample.h"
-using cv::Mat;
-%}
-
-//make sure to import the image_pool as it is 
-//referenced by the Processor java generated
-//class
-%typemap(javaimports) CVSample "
-import com.opencv.jni.*;// import the opencv java bindings
-"
-class CVSample
-{
-public:
-  void canny(const Mat& input, Mat& output, int edgeThresh);
-  void invert(Mat& inout);
-  void blur(Mat& inout, int half_kernel_size);
-};
diff --git a/android/apps/OpenCV_SAMPLE/jni/cvsample.cpp b/android/apps/OpenCV_SAMPLE/jni/cvsample.cpp
deleted file mode 100644
index 0f9eea9dc6..0000000000
--- a/android/apps/OpenCV_SAMPLE/jni/cvsample.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "cvsample.h"
-#include <opencv2/imgproc/imgproc.hpp>
-
-void CVSample::canny(const cv::Mat& input, cv::Mat& output, int edgeThresh)
-{
-  if (input.empty())
-    return;
-  cv::Mat gray;
-  if (input.channels() == 3)
-  {
-    cv::cvtColor(input, gray, CV_RGB2GRAY);
-  }
-  else
-    gray = input;
-  cv::Canny(gray, output, edgeThresh, edgeThresh * 3, 3);
-}
-
-void CVSample::invert(cv::Mat& inout)
-{
-  cv::bitwise_not(inout, inout);
-}
-void CVSample::blur(cv::Mat& inout, int half_kernel_size)
-{
-  int ksz = half_kernel_size*2 + 1;
-  cv::Size kernel(ksz,ksz);
-  cv::blur(inout,inout,kernel);
-}
diff --git a/android/apps/OpenCV_SAMPLE/jni/cvsample.h b/android/apps/OpenCV_SAMPLE/jni/cvsample.h
deleted file mode 100644
index 345a35c3b6..0000000000
--- a/android/apps/OpenCV_SAMPLE/jni/cvsample.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include <opencv2/core/core.hpp>
-
-class CVSample
-{
-public:
-  void canny(const cv::Mat& input, cv::Mat& output, int edgeThresh);
-  void invert(cv::Mat& inout);
-  void blur(cv::Mat& inout, int half_kernel_size);
-};
diff --git a/android/apps/OpenCV_SAMPLE/project_create.sh b/android/apps/OpenCV_SAMPLE/project_create.sh
deleted file mode 100755
index c058d198bb..0000000000
--- a/android/apps/OpenCV_SAMPLE/project_create.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#this generates an ant based cli build of the android-jni project
-android update project --name OpenCV_SAMPLE \
---path .
diff --git a/android/apps/OpenCV_SAMPLE/res/drawable-ldpi/icon.png b/android/apps/OpenCV_SAMPLE/res/drawable-ldpi/icon.png
deleted file mode 100644
index 5e11406cb2..0000000000
Binary files a/android/apps/OpenCV_SAMPLE/res/drawable-ldpi/icon.png and /dev/null differ
diff --git a/android/apps/OpenCV_SAMPLE/res/drawable-mdpi/icon.png b/android/apps/OpenCV_SAMPLE/res/drawable-mdpi/icon.png
deleted file mode 100644
index a591eb892d..0000000000
Binary files a/android/apps/OpenCV_SAMPLE/res/drawable-mdpi/icon.png and /dev/null differ
diff --git a/android/apps/OpenCV_SAMPLE/res/menu/sample_menu.xml b/android/apps/OpenCV_SAMPLE/res/menu/sample_menu.xml
deleted file mode 100644
index 8cf02d7b7f..0000000000
--- a/android/apps/OpenCV_SAMPLE/res/menu/sample_menu.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<menu
-  xmlns:android="http://schemas.android.com/apk/res/android">
-<item android:id="@+id/cv_menu_invert" android:title="Invert"></item>
-<item android:id="@+id/cv_menu_canny" android:title="Canny"></item>
-<item android:id="@+id/cv_menu_blur" android:title="Blur"></item>
-<item android:id="@+id/cv_menu_nothing" android:title="Nothing"></item>
-</menu>
diff --git a/android/apps/OpenCV_SAMPLE/res/values/strings.xml b/android/apps/OpenCV_SAMPLE/res/values/strings.xml
deleted file mode 100644
index 1b7d2e73b6..0000000000
--- a/android/apps/OpenCV_SAMPLE/res/values/strings.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="hello">Hello World, OpenCV_SAMPLE!</string>
-    <string name="app_name">OpenCV SAMPLE</string>
-</resources>
diff --git a/android/apps/OpenCV_SAMPLE/src/com/OpenCV_SAMPLE/OpenCV_SAMPLE.java b/android/apps/OpenCV_SAMPLE/src/com/OpenCV_SAMPLE/OpenCV_SAMPLE.java
deleted file mode 100644
index 7002cee8fd..0000000000
--- a/android/apps/OpenCV_SAMPLE/src/com/OpenCV_SAMPLE/OpenCV_SAMPLE.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package com.OpenCV_SAMPLE;
-
-import java.util.LinkedList;
-
-import android.os.Bundle;
-import android.view.Menu;
-import android.view.MenuInflater;
-import android.view.MenuItem;
-
-import com.OpenCV_SAMPLE.jni.CVSample;
-import com.opencv.camera.CameraActivity;
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.jni.Mat;
-import com.opencv.jni.image_pool;
-
-public class OpenCV_SAMPLE extends CameraActivity {
-
-	private int do_what = R.id.cv_menu_nothing;
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		MenuInflater menu_flater = new MenuInflater(this);
-		menu_flater.inflate(R.menu.sample_menu, menu);
-		return true;
-	}
-
-	@Override
-	public boolean onMenuItemSelected(int featureId, MenuItem item) {
-		switch (item.getItemId()) {
-		case R.id.cv_menu_blur:
-		case R.id.cv_menu_canny:
-		case R.id.cv_menu_invert:
-		case R.id.cv_menu_nothing:
-			do_what = item.getItemId();
-			break;
-		default:
-			return false;
-
-		}
-		return true;
-	}
-
-	/** Called when the activity is first created. */
-	@Override
-	public void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-	}
-
-	@Override
-	protected LinkedList<PoolCallback> getCallBackStack() {
-		LinkedList<PoolCallback> list = new LinkedList<NativeProcessor.PoolCallback>();
-		list.add(samplePoolCallback);
-		return list;
-	}
-
-	CVSample cvsample = new CVSample();
-	Mat canny = new Mat();
-	PoolCallback samplePoolCallback = new PoolCallback() {
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-			Mat grey = pool.getGrey(idx);
-			Mat color = pool.getImage(idx);
-			Mat draw_img = color;
-			switch (do_what) {
-			case R.id.cv_menu_blur:
-				cvsample.blur(draw_img, 5);
-				break;
-			case R.id.cv_menu_canny:
-				cvsample.canny(grey, canny, 15);
-				draw_img = canny;
-				break;
-			case R.id.cv_menu_invert:
-				cvsample.invert(draw_img);
-				break;
-			case R.id.cv_menu_nothing:
-				break;
-			}
-			pool.addImage(idx + 1, draw_img);
-			glview.getDrawCallback().process(idx + 1, pool, timestamp,
-					nativeProcessor);
-		}
-	};
-
-}
\ No newline at end of file
diff --git a/android/apps/camera_template/AndroidManifest.xml b/android/apps/camera_template/AndroidManifest.xml
deleted file mode 100644
index 6af45ffec0..0000000000
--- a/android/apps/camera_template/AndroidManifest.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-	package="com.foo.bar" android:versionCode="1" android:versionName="1.0"	>
-	
-	<application android:debuggable="true" android:icon="@drawable/icon">
-		<activity android:name=".FooBar" android:screenOrientation="landscape"
-			android:configChanges="orientation|keyboardHidden|keyboard"
-			android:label="@string/app_name"
-			>
-			<intent-filter>
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-		</activity>
-
-	</application>
-
-
-
-	<uses-feature android:glEsVersion="0x00020000" />
-
-	<uses-permission android:name="android.permission.CAMERA"></uses-permission>
-
-	<uses-sdk android:minSdkVersion="7" />
-
-	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
-</manifest> 
\ No newline at end of file
diff --git a/android/apps/camera_template/Makefile b/android/apps/camera_template/Makefile
deleted file mode 100644
index 4bec050c02..0000000000
--- a/android/apps/camera_template/Makefile
+++ /dev/null
@@ -1,100 +0,0 @@
-#Re-usable Makefile template for
-#android-ndk + swig projects
-# The path to the NDK, requires crystax version r-4 for now, due to support
-# for the standard library
-
-# load environment from local make file
-LOCAL_ENV_MK=local.env.mk
-ifneq "$(wildcard $(LOCAL_ENV_MK))" ""
-include $(LOCAL_ENV_MK)
-else
-$(shell cp sample.$(LOCAL_ENV_MK) $(LOCAL_ENV_MK))
-$(info ERROR local environement not setup! try:)
-$(info gedit $(LOCAL_ENV_MK))
-$(error Please setup the $(LOCAL_ENV_MK) - the default was just created')
-endif
-ifndef ARM_TARGETS
-ARM_TARGETS="armeabi armeabi-v7a"
-endif
-ANDROID_NDK_BASE = $(ANDROID_NDK_ROOT)
-
-$(info OPENCV_CONFIG = $(OPENCV_CONFIG))
-
-ifndef PROJECT_PATH
-$(info PROJECT_PATH defaulting to this directory)
-PROJECT_PATH=.
-endif
-
-android_jni=../../android-jni/jni
-
-# The name of the native library
-LIBNAME = libfoobar.so
-
-#define the main jni swig interface file
-#the desired java package name
-#and the desired java directory
-#notice that the package and the java dir
-#are related...
-SWIG_MAIN = jni/foobar.i
-SWIG_JAVA_PACKAGE = com.foo.bar.jni
-SWIG_JAVA_DIR = src/com/foo/bar/jni
-
-SWIG_BASE = foobar
-
-#swig definitions - auto as long as all the
-#swig interface files are in jni/*.i
-SWIG_JAVA_OUT = $(wildcard $(SWIG_JAVA_DIR)/*.java)
-SWIG_IS = $(wildcard jni/*.i)
-#the main swig file that includes others
-SWIG_MAIN = jni/foobar.i
-SWIG_C_DIR = jni/gen
-SWIG_C_OUT = $(SWIG_C_DIR)/foo_swig.cpp
-
-# Find all the C++ sources in the native folder
-SOURCES = $(wildcard jni/*.cpp)
-HEADERS = $(wildcard jni/*.h)
-
-ANDROID_MKS = $(wildcard jni/*.mk)
-
-
-BUILD_DEFS=OPENCV_CONFIG=$(OPENCV_CONFIG) \
-	PROJECT_PATH=$(PROJECT_PATH) \
-	V=$(V) \
-	$(NDK_FLAGS) \
-	ARM_TARGETS=$(ARM_TARGETS) \
-	SWIG_C_OUT=$(SWIG_C_OUT)
-
-# The real native library stripped of symbols
-LIB		= libs/armeabi-v7a/$(LIBNAME) libs/armeabi/$(LIBNAME)
-
-
-all:	$(LIB)
-
-
-#calls the ndk-build script, passing it OPENCV_ROOT and OPENCV_LIBS_DIR
-$(LIB): $(SWIG_C_OUT) $(SOURCES) $(HEADERS) $(ANDROID_MKS)
-	$(ANDROID_NDK_BASE)/ndk-build $(BUILD_DEFS)
-
-
-#this creates the swig wrappers
-$(SWIG_C_OUT): $(SWIG_IS)
-	make clean-swig &&\
-	mkdir -p $(SWIG_C_DIR) &&\
-	mkdir -p $(SWIG_JAVA_DIR) &&\
-	swig -java -c++ -I$(android_jni) -package  "$(SWIG_JAVA_PACKAGE)" \
-	-outdir $(SWIG_JAVA_DIR) \
-	-o $(SWIG_C_OUT) $(SWIG_MAIN)
-	
-	
-#clean targets
-.PHONY: clean  clean-swig cleanall
-
-#this deletes the generated swig java and the generated c wrapper
-clean-swig:
-	rm -f $(SWIG_JAVA_OUT) $(SWIG_C_OUT)
-	
-#does clean-swig and then uses the ndk-build clean
-clean: clean-swig
-	$(ANDROID_NDK_BASE)/ndk-build clean $(BUILD_DEFS)
-
-
diff --git a/android/apps/camera_template/README.txt b/android/apps/camera_template/README.txt
deleted file mode 100644
index 14d57b56f6..0000000000
--- a/android/apps/camera_template/README.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-see http://code.google.com/p/android-opencv/wiki/camera_template
-
diff --git a/android/apps/camera_template/build.sh b/android/apps/camera_template/build.sh
deleted file mode 100644
index 92772c3a78..0000000000
--- a/android/apps/camera_template/build.sh
+++ /dev/null
@@ -1 +0,0 @@
-make OPENCV_ROOT=../../opencv V=0
diff --git a/android/apps/camera_template/clean.sh b/android/apps/camera_template/clean.sh
deleted file mode 100644
index 121e391e4e..0000000000
--- a/android/apps/camera_template/clean.sh
+++ /dev/null
@@ -1 +0,0 @@
-make OPENCV_ROOT=../../opencv V=0 clean
diff --git a/android/apps/camera_template/default.properties b/android/apps/camera_template/default.properties
deleted file mode 100644
index 22f3e44f0e..0000000000
--- a/android/apps/camera_template/default.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
-# This file must be checked in Version Control Systems.
-# 
-# To customize properties used by the Ant build system use,
-# "build.properties", and override values to adapt the script to your
-# project structure.
-
-android.library.reference.1=../../android-jni/
-# Project target.
-target=android-7
diff --git a/android/apps/camera_template/jni/Android.mk b/android/apps/camera_template/jni/Android.mk
deleted file mode 100644
index a943255bd1..0000000000
--- a/android/apps/camera_template/jni/Android.mk
+++ /dev/null
@@ -1,23 +0,0 @@
-# date: Summer, 2010 
-# author: Ethan Rublee
-# contact: ethan.rublee@gmail.com
-#
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-#define OPENCV_INCLUDES and OPENCV_LIBS
-include $(OPENCV_CONFIG)
-
-LOCAL_LDLIBS += $(OPENCV_LIBS) $(ANDROID_OPENCV_LIBS) -llog -lGLESv2
-    
-LOCAL_C_INCLUDES +=  $(OPENCV_INCLUDES) $(ANDROID_OPENCV_INCLUDES)
-
-LOCAL_MODULE    := foobar
-
-#make sure to pass in SWIG_C_OUT=gen/foobar_swig.cpp
-#done in the makefile
-LOCAL_SRC_FILES := gen/foo_swig.cpp TestBar.cpp
-
-include $(BUILD_SHARED_LIBRARY)
-
diff --git a/android/apps/camera_template/jni/Application.mk b/android/apps/camera_template/jni/Application.mk
deleted file mode 100644
index 0bbce43113..0000000000
--- a/android/apps/camera_template/jni/Application.mk
+++ /dev/null
@@ -1,2 +0,0 @@
-# The ARMv7 is significanly faster due to the use of the hardware FPU
-APP_ABI := $(ARM_TARGETS)
\ No newline at end of file
diff --git a/android/apps/camera_template/jni/TestBar.cpp b/android/apps/camera_template/jni/TestBar.cpp
deleted file mode 100644
index 869113a310..0000000000
--- a/android/apps/camera_template/jni/TestBar.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "TestBar.h"
-
-void BarBar::crazy(){
-
-}
diff --git a/android/apps/camera_template/jni/TestBar.h b/android/apps/camera_template/jni/TestBar.h
deleted file mode 100644
index e919f8f324..0000000000
--- a/android/apps/camera_template/jni/TestBar.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * TestBar.h
- *
- *  Created on: Jul 17, 2010
- *      Author: ethan
- */
-
-#ifndef TESTBAR_H_
-#define TESTBAR_H_
-
-#include "image_pool.h"
-
-struct FooBarStruct {
-
-	int pool_image_count(image_pool* pool){
-		return pool->getCount();
-	}
-
-};
-
-class BarBar{
-public:
-	void crazy();
-};
-
-#endif /* TESTBAR_H_ */
diff --git a/android/apps/camera_template/jni/foobar.i b/android/apps/camera_template/jni/foobar.i
deleted file mode 100644
index a66a059322..0000000000
--- a/android/apps/camera_template/jni/foobar.i
+++ /dev/null
@@ -1,68 +0,0 @@
-/* File : foobar.i */
-%module foobar
-
-/*
- * the java import code muse be included for the opencv jni wrappers
- * this means that the android project must reference opencv/android as a project
- * see the default.properties for how this is done
- */
-%pragma(java) jniclassimports=%{
-import com.opencv.jni.*; //import the android-opencv jni wrappers
-%}
-
-%pragma(java) jniclasscode=%{
-	static {
-		try {
-			//load the cvcamera library, make sure that libcvcamera.so is in your <project>/libs/armeabi directory
-			//so that android sdk automatically installs it along with the app.
-			
-			//the android-opencv lib must be loaded first inorder for the cvcamera
-			//lib to be found
-			//check the apk generated, by opening it in an archive manager, to verify that
-			//both these libraries are present
-			System.loadLibrary("android-opencv");
-			System.loadLibrary("foobar");
-		} catch (UnsatisfiedLinkError e) {
-			//badness
-			throw e;
-		}
-	}
-
-%}
-
-%{
-#include "image_pool.h"
-#include "TestBar.h"
-using namespace cv;
-%}
-
-
-//import the android-cv.i file so that swig is aware of all that has been previous defined
-//notice that it is not an include....
-%import "android-cv.i"
-
-
-//make sure to import the image_pool as it is 
-//referenced by the Processor java generated
-//class
-%typemap(javaimports) FooBarStruct "
-import com.opencv.jni.image_pool;// import the image_pool interface for playing nice with
-								 // android-opencv
-
-/** FooBar - template
-*/"
-
-//sample inline class that needs to include image_pool
-struct FooBarStruct {
-	
-	int pool_image_count(image_pool* pool){
-		return pool->getCount();
-	}
-	
-};
-
-//sample jni class
-class BarBar{
-public:
-	void crazy();
-};
diff --git a/android/apps/camera_template/res/drawable-ldpi/icon.png b/android/apps/camera_template/res/drawable-ldpi/icon.png
deleted file mode 100644
index 5e11406cb2..0000000000
Binary files a/android/apps/camera_template/res/drawable-ldpi/icon.png and /dev/null differ
diff --git a/android/apps/camera_template/res/drawable-mdpi/icon.png b/android/apps/camera_template/res/drawable-mdpi/icon.png
deleted file mode 100644
index a591eb892d..0000000000
Binary files a/android/apps/camera_template/res/drawable-mdpi/icon.png and /dev/null differ
diff --git a/android/apps/camera_template/res/values/strings.xml b/android/apps/camera_template/res/values/strings.xml
deleted file mode 100644
index 5ff41dc254..0000000000
--- a/android/apps/camera_template/res/values/strings.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<string name="app_name">FooBar</string>
-<string name="about_str">FooBar is a template app for the android-opencv project!\nVisit http://code.google.com/p/android-opencv for details.</string>
-<string name="about_title">About FooBar</string>
-<string name="about_menu">About</string>
-<string name="ok">O.K.</string>
-</resources>
diff --git a/android/apps/camera_template/sample.local.env.mk b/android/apps/camera_template/sample.local.env.mk
deleted file mode 100644
index b0cf78fd36..0000000000
--- a/android/apps/camera_template/sample.local.env.mk
+++ /dev/null
@@ -1,4 +0,0 @@
-#location of android-opencv port of OpenCV to android
-OPENCV_CONFIG=../../build/android-opencv.mk
-ANDROID_NDK_ROOT=$(HOME)/android-ndk-r4-crystax
-ARM_TARGETS="armeabi armeabi-v7a"
diff --git a/android/apps/camera_template/src/com/foo/bar/FooBar.java b/android/apps/camera_template/src/com/foo/bar/FooBar.java
deleted file mode 100644
index 6bc31be5b0..0000000000
--- a/android/apps/camera_template/src/com/foo/bar/FooBar.java
+++ /dev/null
@@ -1,224 +0,0 @@
-package com.foo.bar;
-
-import java.util.LinkedList;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.app.Dialog;
-import android.content.DialogInterface;
-import android.os.Bundle;
-import android.util.Log;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.MotionEvent;
-import android.view.Window;
-import android.view.WindowManager;
-import android.view.ViewGroup.LayoutParams;
-import android.widget.FrameLayout;
-import android.widget.LinearLayout;
-
-//make sure you have the OpenCV project open, so that the
-//android-sdk can find it!
-import com.foo.bar.jni.BarBar;
-import com.foo.bar.jni.FooBarStruct;
-import com.opencv.camera.NativePreviewer;
-import com.opencv.camera.NativeProcessor;
-import com.opencv.camera.NativeProcessor.PoolCallback;
-import com.opencv.jni.image_pool;
-import com.opencv.opengl.GL2CameraViewer;
-
-public class FooBar extends Activity {
-
-	private final int FOOBARABOUT = 0;
-
-	@Override
-	protected Dialog onCreateDialog(int id) {
-		Dialog dialog;
-		switch (id) {
-		case FOOBARABOUT:
-			AlertDialog.Builder builder = new AlertDialog.Builder(this);
-			builder.setTitle(R.string.about_title);
-			builder.setMessage(R.string.about_str);
-			builder.setPositiveButton(R.string.ok,
-					new DialogInterface.OnClickListener() {
-
-						@Override
-						public void onClick(DialogInterface dialog, int which) {
-							dismissDialog(FOOBARABOUT);
-
-						}
-					});
-			dialog = builder.create();
-		default:
-			dialog = null;
-		}
-		return dialog;
-	}
-
-	/*
-	 * Handle the capture button as follows...
-	 */
-	@Override
-	public boolean onKeyUp(int keyCode, KeyEvent event) {
-
-		switch (keyCode) {
-		case KeyEvent.KEYCODE_CAMERA:
-		case KeyEvent.KEYCODE_SPACE:
-		case KeyEvent.KEYCODE_DPAD_CENTER:
-			// capture button pressed here
-			return true;
-
-		default:
-			return super.onKeyUp(keyCode, event);
-		}
-
-	}
-
-	/*
-	 * Handle the capture button as follows... On some phones there is no
-	 * capture button, only trackball
-	 */
-	@Override
-	public boolean onTrackballEvent(MotionEvent event) {
-		if (event.getAction() == MotionEvent.ACTION_UP) {
-			// capture button pressed
-			return true;
-		}
-		return super.onTrackballEvent(event);
-	}
-
-	@Override
-	public boolean onCreateOptionsMenu(Menu menu) {
-		menu.add(R.string.about_menu);
-		return true;
-	}
-
-	private NativePreviewer mPreview;
-	private GL2CameraViewer glview;
-
-	@Override
-	public boolean onOptionsItemSelected(MenuItem item) {
-		// example menu
-		if (item.getTitle().equals(
-				getResources().getString(R.string.about_menu))) {
-			showDialog(FOOBARABOUT);
-		}
-		return true;
-	}
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-
-		requestWindowFeature(Window.FEATURE_NO_TITLE);
-		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
-				WindowManager.LayoutParams.FLAG_FULLSCREEN);
-
-		FrameLayout frame = new FrameLayout(this);
-
-		// Create our Preview view and set it as the content of our activity.
-		mPreview = new NativePreviewer(getApplication(), 300, 300);
-
-		LayoutParams params = new LayoutParams(LayoutParams.WRAP_CONTENT,
-				LayoutParams.WRAP_CONTENT);
-		params.height = getWindowManager().getDefaultDisplay().getHeight();
-		params.width = (int) (params.height * 4.0 / 2.88);
-
-		LinearLayout vidlay = new LinearLayout(getApplication());
-
-		vidlay.setGravity(Gravity.CENTER);
-		vidlay.addView(mPreview, params);
-		frame.addView(vidlay);
-
-		// make the glview overlay ontop of video preview
-		mPreview.setZOrderMediaOverlay(false);
-
-		glview = new GL2CameraViewer(getApplication(), false, 0, 0);
-		glview.setZOrderMediaOverlay(true);
-		glview.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,
-				LayoutParams.FILL_PARENT));
-		frame.addView(glview);
-
-		setContentView(frame);
-
-	}
-
-	@Override
-	protected void onPause() {
-		super.onPause();
-
-		// IMPORTANT
-		// must tell the NativePreviewer of a pause
-		// and the glview - so that they can release resources and start back up
-		// properly
-		// failing to do this will cause the application to crash with no
-		// warning
-		// on restart
-		// clears the callback stack
-		mPreview.onPause();
-
-		glview.onPause();
-
-	}
-
-	@Override
-	protected void onResume() {
-		super.onResume();
-
-		// resume the opengl viewer first
-		glview.onResume();
-
-		// add an initial callback stack to the preview on resume...
-		// this one will just draw the frames to opengl
-		LinkedList<NativeProcessor.PoolCallback> cbstack = new LinkedList<PoolCallback>();
-
-		// SpamProcessor will be called first
-		cbstack.add(new SpamProcessor());
-
-		// then the same idx and pool will be passed to
-		// the glview callback -
-		// so operate on the image at idx, and modify, and then
-		// it will be drawn in the glview
-		// or remove this, and call glview manually in SpamProcessor
-		// cbstack.add(glview.getDrawCallback());
-
-		mPreview.addCallbackStack(cbstack);
-		mPreview.onResume();
-
-	}
-
-	class SpamProcessor implements NativeProcessor.PoolCallback {
-
-		FooBarStruct foo = new FooBarStruct();
-		BarBar barbar = new BarBar();
-
-		@Override
-		public void process(int idx, image_pool pool, long timestamp,
-				NativeProcessor nativeProcessor) {
-
-			// example of using the jni generated FoobarStruct;
-			int nImages = foo.pool_image_count(pool);
-			Log.i("foobar", "Number of images in pool: " + nImages);
-
-			// call a function - this function does absolutely nothing!
-			barbar.crazy();
-
-			// sample processor
-			// this gets called every frame in the order of the list
-			// first add to the callback stack linked list will be the
-			// first called
-			// the idx and pool may be used to get the cv::Mat
-			// that is the latest frame being passed.
-			// pool.getClass(idx)
-
-			// these are what the glview.getDrawCallback() calls
-			glview.drawMatToGL(idx, pool);
-			glview.requestRender();
-
-		}
-
-	}
-
-}
diff --git a/android/scripts/build.cmd b/android/scripts/build.cmd
index be62d05689..97b9cd96b8 100644
--- a/android/scripts/build.cmd
+++ b/android/scripts/build.cmd
@@ -19,7 +19,6 @@ POPD
 IF NOT DEFINED BUILD_DIR SET BUILD_DIR=build
 IF NOT DEFINED ARM_TARGET SET ARM_TARGET=armeabi-v7a
 SET OPENCV_BUILD_DIR=%SCRIPTS_DIR%\..\%BUILD_DIR%
-SET ANDROID_OPENCV_BUILD_DIR=%SCRIPTS_DIR%\..\android-opencv\%BUILD_DIR%
 
 :: check that all required variables defined
 PUSHD .
@@ -34,9 +33,6 @@ IF NOT %BUILD_JAVA_PART%==1 GOTO required_variables_checked
 IF NOT DEFINED ANDROID_SDK (ECHO. & ECHO You should set an environment variable ANDROID_SDK to the full path to your copy of Android SDK & GOTO end)
 (CD "%ANDROID_SDK%" 2>NUL) || (ECHO. & ECHO Directory "%ANDROID_SDK%" specified by ANDROID_SDK variable does not exist & GOTO end)
 
-IF NOT DEFINED SWIG_DIR (ECHO. & ECHO You should set an environment variable SWIG_DIR to the full path to SWIG root & GOTO end)
-(CD "%SWIG_DIR%" 2>NUL) || (ECHO. & ECHO Directory "%SWIG_DIR%" specified by SWIG_DIR variable does not exist & GOTO end)
-
 IF NOT DEFINED ANT_DIR (ECHO. & ECHO You should set an environment variable ANT_DIR to the full path to Apache Ant root & GOTO end)
 (CD "%ANT_DIR%" 2>NUL) || (ECHO. & ECHO Directory "%ANT_DIR%" specified by ANT_DIR variable does not exist & GOTO end)
 
@@ -57,10 +53,10 @@ ECHO ARM_TARGET=%ARM_TARGET%
 ECHO.
 IF NOT %BUILD_OPENCV%==1 GOTO other-cmake
 :opencv-cmake
-("%CMAKE_EXE%" -G"MinGW Makefiles" -DARM_TARGET="%ARM_TARGET%" -C "%SOURCE_DIR%\CMakeCache.android.initial.cmake" -DCMAKE_TOOLCHAIN_FILE="%SOURCE_DIR%"\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM="%MAKE_EXE%" "%SOURCE_DIR%\..") && GOTO cmakefin
+("%CMAKE_EXE%" -G"MinGW Makefiles" -DARM_TARGET="%ARM_TARGET%" -C "%SOURCE_DIR%\CMakeCache.android.initial.cmake" -DCMAKE_TOOLCHAIN_FILE="%SOURCE_DIR%"\android.toolchain.cmake -DCMAKE_MAKE_PROGRAM="%MAKE_EXE%" %* "%SOURCE_DIR%\..") && GOTO cmakefin
 ECHO. & ECHO cmake failed &	GOTO end
 :other-cmake
-("%CMAKE_EXE%" -G"MinGW Makefiles" -DARM_TARGET="%ARM_TARGET%" -DOpenCV_DIR="%OPENCV_BUILD_DIR%" -DAndroidOpenCV_DIR="%ANDROID_OPENCV_BUILD_DIR%"  -DCMAKE_PROGRAM_PATH="%SWIG_DIR%" -DCMAKE_TOOLCHAIN_FILE="%OPENCV_BUILD_DIR%\..\android.toolchain.cmake" -DCMAKE_MAKE_PROGRAM="%MAKE_EXE%" "%SOURCE_DIR%") && GOTO cmakefin
+("%CMAKE_EXE%" -G"MinGW Makefiles" -DARM_TARGET="%ARM_TARGET%" -DOpenCV_DIR="%OPENCV_BUILD_DIR%" -DCMAKE_TOOLCHAIN_FILE="%OPENCV_BUILD_DIR%\..\android.toolchain.cmake" -DCMAKE_MAKE_PROGRAM="%MAKE_EXE%" %* "%SOURCE_DIR%") && GOTO cmakefin
 ECHO. & ECHO cmake failed &	GOTO end
 :cmakefin
 
diff --git a/android/scripts/cmake_android.sh b/android/scripts/cmake_android.sh
index e95d35f9b3..c17110e69b 100644
--- a/android/scripts/cmake_android.sh
+++ b/android/scripts/cmake_android.sh
@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build
 cd build
 
-cmake -C ../CMakeCache.android.initial.cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake ../..
+cmake -C ../CMakeCache.android.initial.cmake -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake $@ ../..
 
diff --git a/android/scripts/cmake_android_armeabi.sh b/android/scripts/cmake_android_armeabi.sh
index 3e6ee1d68c..961c9d685f 100644
--- a/android/scripts/cmake_android_armeabi.sh
+++ b/android/scripts/cmake_android_armeabi.sh
@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build_armeabi
 cd build_armeabi
 
-cmake -C ../CMakeCache.android.initial.cmake -DARM_TARGET=armeabi -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake ../..
+cmake -C ../CMakeCache.android.initial.cmake -DARM_TARGET=armeabi -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake $@ ../..
 
diff --git a/android/scripts/cmake_android_neon.sh b/android/scripts/cmake_android_neon.sh
index 7b29b9f1f9..4212210491 100644
--- a/android/scripts/cmake_android_neon.sh
+++ b/android/scripts/cmake_android_neon.sh
@@ -4,5 +4,5 @@ cd `dirname $0`/..
 mkdir -p build_neon
 cd build_neon
 
-cmake -C ../CMakeCache.android.initial.cmake -DARM_TARGET="armeabi-v7a with NEON" -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake ../..
+cmake -C ../CMakeCache.android.initial.cmake -DARM_TARGET="armeabi-v7a with NEON" -DCMAKE_TOOLCHAIN_FILE=../android.toolchain.cmake $@ ../..
 
diff --git a/android/scripts/package.sh b/android/scripts/package.sh
new file mode 100644
index 0000000000..c2593936e0
--- /dev/null
+++ b/android/scripts/package.sh
@@ -0,0 +1,114 @@
+#!/bin/sh
+cd `dirname $0`/..
+
+ANDROID_DIR=`pwd`
+
+rm -rf package
+mkdir -p package
+cd package
+
+PRG_DIR=`pwd`
+mkdir opencv
+
+# neon-enabled build
+#cd $PRG_DIR
+#mkdir build-neon
+#cd build-neon
+
+#cmake -C "$ANDROID_DIR/CMakeCache.android.initial.cmake" -DARM_TARGET="armeabi-v7a with NEON" -DBUILD_DOCS=OFF -DBUILD_TESTS=OFF -DBUILD_EXAMPLES=OFF -DBUILD_ANDROID_EXAMPLES=OFF -DCMAKE_TOOLCHAIN_FILE="$ANDROID_DIR/android.toolchain.cmake" -DCMAKE_INSTALL_PREFIX="$PRG_DIR/opencv" "$ANDROID_DIR/.."  || exit 1
+#make -j8 install/strip || exit 1
+
+#cd "$PRG_DIR/opencv"
+#rm -rf doc include src .classpath .project AndroidManifest.xml default.properties share/OpenCV/haarcascades share/OpenCV/lbpcascades share/OpenCV/*.cmake share/OpenCV/OpenCV.mk
+#mv libs/armeabi-v7a libs/armeabi-v7a-neon
+#mv share/OpenCV/3rdparty/libs/armeabi-v7a share/OpenCV/3rdparty/libs/armeabi-v7a-neon
+
+
+# armeabi-v7a build
+cd "$PRG_DIR"
+mkdir build
+cd build
+
+cmake -C "$ANDROID_DIR/CMakeCache.android.initial.cmake" -DARM_TARGET="armeabi-v7a" -DBUILD_DOCS=OFF -DBUILD_TESTS=ON -DBUILD_EXAMPLES=OFF -DBUILD_ANDROID_EXAMPLES=ON -DCMAKE_TOOLCHAIN_FILE="$ANDROID_DIR/android.toolchain.cmake" -DCMAKE_INSTALL_PREFIX="$PRG_DIR/opencv" "$ANDROID_DIR/.."  || exit 1
+make -j8 install/strip || exit 1
+
+cd "$PRG_DIR/opencv"
+rm -rf doc include src .classpath .project AndroidManifest.xml default.properties share/OpenCV/haarcascades share/OpenCV/lbpcascades share/OpenCV/*.cmake share/OpenCV/OpenCV.mk
+
+
+# armeabi build
+cd "$PRG_DIR/build"
+rm -rf CMakeCache.txt
+
+cmake -C "$ANDROID_DIR/CMakeCache.android.initial.cmake" -DARM_TARGET="armeabi" -DBUILD_DOCS=ON -DBUILD_TESTS=ON -DBUILD_EXAMPLES=OFF -DBUILD_ANDROID_EXAMPLES=ON -DINSTALL_ANDROID_EXAMPLES=ON -DCMAKE_TOOLCHAIN_FILE="$ANDROID_DIR/android.toolchain.cmake" -DCMAKE_INSTALL_PREFIX="$PRG_DIR/opencv" "$ANDROID_DIR/.."  || exit 1
+make -j8 install/strip docs || exit 1
+
+find doc -name "*.pdf" -exec cp {} $PRG_DIR/opencv/doc \;
+
+cd $PRG_DIR
+rm -rf opencv/doc/CMakeLists.txt
+cp "$ANDROID_DIR/README.android" opencv/
+cp "$ANDROID_DIR/../README" opencv/
+
+
+# get opencv version
+CV_VERSION=`grep -o "[0-9]\+\.[0-9]\+\.[0-9]\+" opencv/share/OpenCV/OpenCVConfig-version.cmake`
+OPENCV_NAME=OpenCV-$CV_VERSION
+mv opencv $OPENCV_NAME
+
+#samples
+cp -r "$ANDROID_DIR/../samples/android" "$PRG_DIR/samples"
+cd "$PRG_DIR/samples"
+
+#enable for loops over items with spaces in their name
+IFS="
+"
+for dir in `ls -1`
+do
+  if [ -f "$dir/default.properties" ]
+  then
+    HAS_REFERENCE=`cat "$dir/default.properties" | grep -c android.library.reference.1`
+    if [ $HAS_REFERENCE = 1 ]
+    then
+      echo -n > "$dir/default.properties"
+      android update project --name "$dir" --target "android-8" --library "../../$OPENCV_NAME" --path "$dir"
+      #echo 'android update project --name "$dir" --target "android-8" --library "../opencv$CV_VERSION" --path "$dir"'
+    fi
+  else
+    rm -rf "$dir"
+  fi
+done
+
+echo "OPENCV_MK_PATH:=../../$OPENCV_NAME/share/OpenCV/OpenCV.mk" > includeOpenCV.mk
+
+
+#clean samples
+cd "$PRG_DIR/samples"
+#remove ignored files/folders
+svn status --no-ignore | grep ^I | cut -c9- | xargs -d \\n rm -rf
+#remove unversioned files/folders
+svn status | grep ^\? | cut -c9- | xargs -d \\n rm -rf
+
+
+#generate "gen" folders to eliminate eclipse warnings
+cd "$PRG_DIR/samples"
+for dir in `ls -1`
+do
+  if [ -d "$dir" ]
+  then
+    mkdir "$dir/gen"
+  fi
+done
+
+
+#generate folders "gen" and "res" for opencv (dummy eclipse stiff)
+cd $PRG_DIR
+mkdir "$OPENCV_NAME/gen"
+mkdir "$OPENCV_NAME/res"
+
+# pack all files
+cd $PRG_DIR
+PRG_NAME=OpenCV-$CV_VERSION-tp-android-bin.tar.bz2
+tar cjpf $PRG_NAME --exclude-vcs $OPENCV_NAME samples || exit -1
+echo
+echo "Package $PRG_NAME is successfully created"
diff --git a/android/scripts/wincfg.cmd.tmpl b/android/scripts/wincfg.cmd.tmpl
index 3ba62a5bd7..f095927616 100644
--- a/android/scripts/wincfg.cmd.tmpl
+++ b/android/scripts/wincfg.cmd.tmpl
@@ -1,11 +1,10 @@
 :: variables required for OpenCV build ::
 :: Note: all pathes should be specified without tailing slashes!
-SET ANDROID_NDK=C:\full\path\to\your\copy\of\android\NDK\android-ndk-r5c
+SET ANDROID_NDK=C:\full\path\to\your\copy\of\android\NDK\android-ndk-r6
 SET CMAKE_EXE=C:\full\path\to\cmake\utility\cmake.exe
 SET MAKE_EXE=C:\full\path\to\native\port\of\make\utility\make.exe
 
 :: variables required for android-opencv build ::
-SET SWIG_DIR=C:\full\path\to\SWIG\directory\swigwin-2.0.3
 SET ANDROID_SDK=C:\full\path\to\your\copy\of\android\SDK\android-sdk-windows
 SET ANT_DIR=C:\full\path\to\ant\directory\apache-ant-1.8.2
 SET JAVA_HOME=C:\full\path\to\JDK\jdk1.6.0_25
@@ -24,4 +23,4 @@ SET BUILD_DIR=build
 ::SET BUILD_DIR=build_neon
 
 :::: other options
-::SET ANDROID_API_LEVEL=8   &:: android-3 is enough for OpenCV but android-8 is recommended
+::SET ANDROID_API_LEVEL=8   &:: android-3 is enough for native part of OpenCV but android-8 is required for Java API and samples
diff --git a/cvconfig.h.cmake b/cvconfig.h.cmake
index e61a2261a7..4bd16dda90 100644
--- a/cvconfig.h.cmake
+++ b/cvconfig.h.cmake
@@ -184,3 +184,5 @@
 /* VideoInput library */
 #cmakedefine HAVE_VIDEOINPUT
 
+/* XIMEA camera support */
+#cmakedefine HAVE_XIMEA
diff --git a/data/CMakeLists.txt b/data/CMakeLists.txt
index 53a305811c..0eba875cb3 100644
--- a/data/CMakeLists.txt
+++ b/data/CMakeLists.txt
@@ -2,6 +2,6 @@ file(GLOB HAAR_CASCADES haarcascades/*.xml)
 file(GLOB LBP_CASCADES lbpcascades/*.xml)
 
 if(NOT WIN32)
-install(FILES ${HAAR_CASCADES} DESTINATION share/opencv/haarcascades COMPONENT main)
-install(FILES ${LBP_CASCADES} DESTINATION share/opencv/lbpcascades COMPONENT main)
+install(FILES ${HAAR_CASCADES} DESTINATION share/OpenCV/haarcascades COMPONENT main)
+install(FILES ${LBP_CASCADES} DESTINATION share/OpenCV/lbpcascades COMPONENT main)
 endif()
diff --git a/data/haarcascades/haarcascade_mcs_leftear.xml b/data/haarcascades/haarcascade_mcs_leftear.xml
new file mode 100644
index 0000000000..a5a0383563
--- /dev/null
+++ b/data/haarcascades/haarcascade_mcs_leftear.xml
@@ -0,0 +1,9322 @@
+<?xml version="1.0"?>
+<!----------------------------------------------------------------------------
+  12x20 Left ear (in the image) detector computed with 5000 positive and 15000
+  negative samples
+
+//////////////////////////////////////////////////////////////////////////
+| Contributors License Agreement
+| 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.
+|
+| Copyright (c) 2011, Modesto Castrillon-Santana (IUSIANI, Universidad de
+| Las Palmas de Gran Canaria, Spain).
+|  All rights reserved.
+|
+| Redistribution and use in source and binary forms, with or without
+| modification, are permitted provided that the following conditions are
+| met:
+|
+|    * Redistributions of source code must retain the above copyright
+|       notice, this list of conditions and the following disclaimer.
+|    * Redistributions in binary form must reproduce the above
+|      copyright notice, this list of conditions and the following
+|      disclaimer in the documentation and/or other materials provided
+|      with the distribution.  
+|    * The name of Contributor may not 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
+| 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.  Back to
+| Top
+//////////////////////////////////////////////////////////////////////////
+
+RESEARCH USE:
+If you are using any of the detectors or involved ideas please cite this paper:
+
+@INPROCEEDINGS{Castrillon11-caepia,
+  author =       "Castrill\'on Santana, M. and Lorenzo Navarro, J. and Hern\'andez Sosa, D. ",
+  title =        "An Study on Ear Detection and its Applications to Face Detection",
+  booktitle =    "Conferencia de la Asociaci�n Espa�ola para la Inteligencia Artificial (CAEPIA)",
+  year =         "2011",
+  month =        "November",
+  address =      "La Laguna, Spain",
+  file = F
+}
+
+More information can be found at http://mozart.dis.ulpgc.es/Gias/modesto.html or in the paper.
+
+COMMERCIAL USE:
+If you have any commercial interest in this work please contact 
+mcastrillon@iusiani.ulpgc.es
+------------------------------------------------------------------------>
+
+<opencv_storage>
+<classifier_LeftEarA_trainNew2011_12_20 type_id="opencv-haar-classifier">
+  <size>
+    12 20</size>
+  <stages>
+    <_>
+      <!-- stage 0 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2798480689525604e-001</threshold>
+            <left_val>-7.1108317375183105e-001</left_val>
+            <right_val>8.3952748775482178e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 12 2 -1.</_>
+                <_>
+                  0 4 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.0366270443191752e-005</threshold>
+            <left_val>-7.7958387136459351e-001</left_val>
+            <right_val>4.1161769628524780e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 1 2.</_>
+                <_>
+                  6 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1398220434784889e-002</threshold>
+            <left_val>5.5991190671920776e-001</left_val>
+            <right_val>-5.2993881702423096e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.8897399082779884e-002</threshold>
+            <left_val>-9.6023030579090118e-002</left_val>
+            <right_val>1.8446889519691467e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.7543441653251648e-003</threshold>
+            <left_val>3.9083909988403320e-001</left_val>
+            <right_val>-7.0798218250274658e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 16 -1.</_>
+                <_>
+                  0 8 12 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2758660130202770e-002</threshold>
+            <left_val>-7.6031517982482910e-001</left_val>
+            <right_val>2.6452711224555969e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 1 -1.</_>
+                <_>
+                  6 0 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.1698651330079883e-005</threshold>
+            <left_val>3.2332289218902588e-001</left_val>
+            <right_val>-5.7402020692825317e-001</right_val></_></_></trees>
+      <stage_threshold>-1.6897829771041870e+000</stage_threshold>
+      <parent>-1</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 1 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7598830163478851e-001</threshold>
+            <left_val>-5.9234100580215454e-001</left_val>
+            <right_val>7.8493958711624146e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 8 -1.</_>
+                <_>
+                  0 4 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.8594089448451996e-002</threshold>
+            <left_val>-6.8187582492828369e-001</left_val>
+            <right_val>3.8166061043739319e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  4 10 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2052910029888153e-001</threshold>
+            <left_val>-3.7438058853149414e-001</left_val>
+            <right_val>5.2112519741058350e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 12 8 8 -1.</_>
+                <_>
+                  4 12 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.1304990351200104e-001</threshold>
+            <left_val>9.7819166257977486e-003</left_val>
+            <right_val>-6.5798282623291016e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 8 8 -1.</_>
+                <_>
+                  4 12 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9179080426692963e-001</threshold>
+            <left_val>8.8993859291076660e-001</left_val>
+            <right_val>-2.3742930591106415e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.7649259902536869e-003</threshold>
+            <left_val>-9.2071659862995148e-002</left_val>
+            <right_val>1.5995720028877258e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 4 6 12 -1.</_>
+                <_>
+                  3 7 6 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.4397800490260124e-003</threshold>
+            <left_val>3.5091850161552429e-001</left_val>
+            <right_val>-5.2880358695983887e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 18 -1.</_>
+                <_>
+                  8 0 2 18 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.1300012767314911e-002</threshold>
+            <left_val>4.7027029097080231e-002</left_val>
+            <right_val>-4.8141419887542725e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 18 -1.</_>
+                <_>
+                  2 0 2 18 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.9818956553936005e-002</threshold>
+            <left_val>-3.0336898565292358e-001</left_val>
+            <right_val>5.7992082834243774e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 16 -1.</_>
+                <_>
+                  1 8 10 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9260480552911758e-002</threshold>
+            <left_val>-6.1189621686935425e-001</left_val>
+            <right_val>2.4700529873371124e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 1 2.</_>
+                <_>
+                  6 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.6981123313307762e-003</threshold>
+            <left_val>3.0427950620651245e-001</left_val>
+            <right_val>-4.3165320158004761e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 1 -1.</_>
+                <_>
+                  3 0 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5766489822417498e-005</threshold>
+            <left_val>-5.4995632171630859e-001</left_val>
+            <right_val>2.4196259677410126e-001</right_val></_></_></trees>
+      <stage_threshold>-1.6203830242156982e+000</stage_threshold>
+      <parent>0</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 2 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9991339743137360e-001</threshold>
+            <left_val>-5.1076048612594604e-001</left_val>
+            <right_val>7.2653311491012573e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 3 2 4 -1.</_>
+                <_>
+                  7 4 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6032690473366529e-004</threshold>
+            <left_val>1.1732880026102066e-001</left_val>
+            <right_val>-1.9851410388946533e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 3 4 6 -1.</_>
+                <_>
+                  3 5 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.2459441833198071e-003</threshold>
+            <left_val>-6.2454998493194580e-001</left_val>
+            <right_val>4.1317841410636902e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 12 -1.</_>
+                <_>
+                  0 6 12 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5343401618301868e-003</threshold>
+            <left_val>-8.2238370180130005e-001</left_val>
+            <right_val>2.2600589692592621e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  4 10 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0757610201835632e-001</threshold>
+            <left_val>-5.5525738000869751e-001</left_val>
+            <right_val>4.3564280867576599e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 3 1 8 -1.</_>
+                <_>
+                  6 5 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.9556613713502884e-003</threshold>
+            <left_val>2.9808950424194336e-001</left_val>
+            <right_val>-3.0220919847488403e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 8 1 -1.</_>
+                <_>
+                  6 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8354369937442243e-005</threshold>
+            <left_val>4.4047379493713379e-001</left_val>
+            <right_val>-6.6946560144424438e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 8 -1.</_>
+                <_>
+                  9 2 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9743980374187231e-004</threshold>
+            <left_val>-2.5094148516654968e-001</left_val>
+            <right_val>1.9814400374889374e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 3 8 1 -1.</_>
+                <_>
+                  6 5 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.4098760554334149e-005</threshold>
+            <left_val>3.0689230561256409e-001</left_val>
+            <right_val>-6.6775608062744141e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 4 13 -1.</_>
+                <_>
+                  8 4 2 13 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7941730096936226e-002</threshold>
+            <left_val>2.7399578690528870e-001</left_val>
+            <right_val>-2.9671499133110046e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 1 8 -1.</_>
+                <_>
+                  3 4 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.3291041695047170e-005</threshold>
+            <left_val>-6.7100298404693604e-001</left_val>
+            <right_val>2.4690890312194824e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 1 2.</_>
+                <_>
+                  0 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.4407112076878548e-003</threshold>
+            <left_val>-5.2723282575607300e-001</left_val>
+            <right_val>2.4782879650592804e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 11 1 6 -1.</_>
+                <_>
+                  6 11 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.9925990402698517e-002</threshold>
+            <left_val>8.2168322801589966e-001</left_val>
+            <right_val>-2.4012729525566101e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 17 -1.</_>
+                <_>
+                  8 0 2 17 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4148030206561089e-003</threshold>
+            <left_val>-3.8689721375703812e-002</left_val>
+            <right_val>1.9318090379238129e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 17 -1.</_>
+                <_>
+                  2 0 2 17 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.2534123659133911e-002</threshold>
+            <left_val>-4.1077169775962830e-001</left_val>
+            <right_val>6.0665780305862427e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 12 8 -1.</_>
+                <_>
+                  0 14 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8917986431624740e-005</threshold>
+            <left_val>-6.7601591348648071e-001</left_val>
+            <right_val>3.1252190470695496e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 6 2 -1.</_>
+                <_>
+                  5 7 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.2447909577749670e-004</threshold>
+            <left_val>1.8520550429821014e-001</left_val>
+            <right_val>-7.7942901849746704e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 7 16 -1.</_>
+                <_>
+                  3 8 7 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8156330042984337e-004</threshold>
+            <left_val>-6.6956442594528198e-001</left_val>
+            <right_val>1.5837380290031433e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 2 -1.</_>
+                <_>
+                  0 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.0366270443191752e-005</threshold>
+            <left_val>-4.6770051121711731e-001</left_val>
+            <right_val>2.4539180099964142e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 8 6 8 -1.</_>
+                <_>
+                  3 12 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.0776848840760067e-005</threshold>
+            <left_val>-6.8354898691177368e-001</left_val>
+            <right_val>1.8664689362049103e-001</right_val></_></_></trees>
+      <stage_threshold>-2.1234118938446045e+000</stage_threshold>
+      <parent>1</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 3 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 8 12 -1.</_>
+                <_>
+                  1 7 4 6 2.</_>
+                <_>
+                  5 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5990820527076721e-001</threshold>
+            <left_val>-6.2714368104934692e-001</left_val>
+            <right_val>7.2424608469009399e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 2 -1.</_>
+                <_>
+                  6 5 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.6372842304408550e-003</threshold>
+            <left_val>8.7740488350391388e-002</left_val>
+            <right_val>-5.2430278062820435e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 3 1 6 -1.</_>
+                <_>
+                  5 5 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.0625150799751282e-003</threshold>
+            <left_val>-4.3119868636131287e-001</left_val>
+            <right_val>4.6857520937919617e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 11 2 7 -1.</_>
+                <_>
+                  10 11 1 7 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5897640734910965e-002</threshold>
+            <left_val>1.5866510570049286e-002</left_val>
+            <right_val>-6.5979748964309692e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 11 7 2 -1.</_>
+                <_>
+                  2 11 7 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.8885440230369568e-002</threshold>
+            <left_val>-2.1157009899616241e-001</left_val>
+            <right_val>6.7942970991134644e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 16 10 4 -1.</_>
+                <_>
+                  2 16 5 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1850179731845856e-001</threshold>
+            <left_val>-1.0366249829530716e-001</left_val>
+            <right_val>7.4645912647247314e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 1 3 -1.</_>
+                <_>
+                  0 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6655250219628215e-003</threshold>
+            <left_val>-6.7015552520751953e-001</left_val>
+            <right_val>2.2192029654979706e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 18 1 2 -1.</_>
+                <_>
+                  11 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4783479097532108e-005</threshold>
+            <left_val>2.5404050946235657e-001</left_val>
+            <right_val>-4.9562969803810120e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 1 2 -1.</_>
+                <_>
+                  0 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.3481962792575359e-004</threshold>
+            <left_val>-7.3370438814163208e-001</left_val>
+            <right_val>2.0266470313072205e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 7 3 3 -1.</_>
+                <_>
+                  9 8 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.3157468363642693e-003</threshold>
+            <left_val>-7.3412007093429565e-001</left_val>
+            <right_val>7.2000503540039063e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  7 5 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.9555149376392365e-002</threshold>
+            <left_val>5.1195901632308960e-001</left_val>
+            <right_val>-2.5446298718452454e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 4 3 -1.</_>
+                <_>
+                  8 5 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.9029072076082230e-003</threshold>
+            <left_val>-5.3299552202224731e-001</left_val>
+            <right_val>8.8295362889766693e-002</right_val></_></_></trees>
+      <stage_threshold>-1.4351799488067627e+000</stage_threshold>
+      <parent>2</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 4 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 5 4 -1.</_>
+                <_>
+                  4 11 5 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.8843306303024292e-002</threshold>
+            <left_val>-5.0631648302078247e-001</left_val>
+            <right_val>6.3027667999267578e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 4 2 4 -1.</_>
+                <_>
+                  7 4 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.2210938408970833e-003</threshold>
+            <left_val>1.7837150394916534e-001</left_val>
+            <right_val>-3.3268490433692932e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 4 2 -1.</_>
+                <_>
+                  5 4 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.9967099428176880e-002</threshold>
+            <left_val>-4.5201331377029419e-001</left_val>
+            <right_val>4.6473979949951172e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 2 8 -1.</_>
+                <_>
+                  8 9 2 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6702869534492493e-001</threshold>
+            <left_val>8.0514347553253174e-001</left_val>
+            <right_val>-4.0616780519485474e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 8 2 -1.</_>
+                <_>
+                  4 9 4 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9976759329438210e-002</threshold>
+            <left_val>2.0976160466670990e-001</left_val>
+            <right_val>-7.3149591684341431e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 8 -1.</_>
+                <_>
+                  0 4 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.1860616803169250e-002</threshold>
+            <left_val>-5.4268407821655273e-001</left_val>
+            <right_val>2.1634259819984436e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 8 1 -1.</_>
+                <_>
+                  2 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2709829956293106e-002</threshold>
+            <left_val>-2.4989350140094757e-001</left_val>
+            <right_val>4.7262668609619141e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 12 4 -1.</_>
+                <_>
+                  3 7 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.4979879856109619e-002</threshold>
+            <left_val>3.0420958995819092e-001</left_val>
+            <right_val>-3.5224550962448120e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 1 2 -1.</_>
+                <_>
+                  0 17 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3223739806562662e-003</threshold>
+            <left_val>-6.9712251424789429e-001</left_val>
+            <right_val>1.6912660002708435e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 16 6 4 -1.</_>
+                <_>
+                  3 18 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3282319307327271e-002</threshold>
+            <left_val>3.3972018957138062e-001</left_val>
+            <right_val>-3.6639729142189026e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 10 4 -1.</_>
+                <_>
+                  5 16 5 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5517599880695343e-001</threshold>
+            <left_val>7.3445862531661987e-001</left_val>
+            <right_val>-1.8277870118618011e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 6 4 12 -1.</_>
+                <_>
+                  8 6 2 12 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9222039282321930e-002</threshold>
+            <left_val>3.5923731327056885e-001</left_val>
+            <right_val>-1.1233209818601608e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3800990581512451e+000</stage_threshold>
+      <parent>3</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 5 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 4 11 -1.</_>
+                <_>
+                  2 5 2 11 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.2616936862468719e-002</threshold>
+            <left_val>-4.8533481359481812e-001</left_val>
+            <right_val>6.1538851261138916e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 1 2.</_>
+                <_>
+                  0 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1619539931416512e-002</threshold>
+            <left_val>-5.7667458057403564e-001</left_val>
+            <right_val>3.8557919859886169e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 8 1 -1.</_>
+                <_>
+                  5 7 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.7566948235034943e-003</threshold>
+            <left_val>2.6634719967842102e-001</left_val>
+            <right_val>-8.2090580463409424e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 10 -1.</_>
+                <_>
+                  0 5 12 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.2315487563610077e-003</threshold>
+            <left_val>-8.0720931291580200e-001</left_val>
+            <right_val>2.0323330163955688e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 3 6 12 -1.</_>
+                <_>
+                  3 7 6 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.3656319137662649e-003</threshold>
+            <left_val>2.0334909856319427e-001</left_val>
+            <right_val>-7.4802142381668091e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 1 -1.</_>
+                <_>
+                  1 0 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2655390310101211e-004</threshold>
+            <left_val>-5.8880287408828735e-001</left_val>
+            <right_val>1.7631030082702637e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 6 6 -1.</_>
+                <_>
+                  4 9 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0345769673585892e-001</threshold>
+            <left_val>-4.2211589217185974e-001</left_val>
+            <right_val>3.3677190542221069e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 2 1 8 -1.</_>
+                <_>
+                  7 4 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7050839960575104e-004</threshold>
+            <left_val>1.8885380029678345e-001</left_val>
+            <right_val>-2.6626259088516235e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 2 8 4 -1.</_>
+                <_>
+                  2 4 8 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1793050362030044e-004</threshold>
+            <left_val>-7.1056002378463745e-001</left_val>
+            <right_val>2.2684849798679352e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 12 7 -1.</_>
+                <_>
+                  3 7 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.7460933029651642e-002</threshold>
+            <left_val>4.2451021075248718e-001</left_val>
+            <right_val>-3.9501309394836426e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 16 6 4 -1.</_>
+                <_>
+                  3 18 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7512679100036621e-002</threshold>
+            <left_val>3.6552980542182922e-001</left_val>
+            <right_val>-3.5724669694900513e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 2 1 18 -1.</_>
+                <_>
+                  10 11 1 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7156290414277464e-004</threshold>
+            <left_val>-3.1259360909461975e-001</left_val>
+            <right_val>1.1446060240268707e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 4 1 16 -1.</_>
+                <_>
+                  1 12 1 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5574887692928314e-002</threshold>
+            <left_val>-2.0559160411357880e-001</left_val>
+            <right_val>8.9941620826721191e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 18 -1.</_>
+                <_>
+                  4 9 4 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1759579647332430e-003</threshold>
+            <left_val>-7.5939810276031494e-001</left_val>
+            <right_val>2.1389579772949219e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 1 -1.</_>
+                <_>
+                  2 0 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8068292825482786e-005</threshold>
+            <left_val>-6.0090541839599609e-001</left_val>
+            <right_val>2.5762718915939331e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 2 1 8 -1.</_>
+                <_>
+                  7 4 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3003520618658513e-004</threshold>
+            <left_val>-4.1466540098190308e-001</left_val>
+            <right_val>2.3084460198879242e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 2 -1.</_>
+                <_>
+                  8 5 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.4361891448497772e-004</threshold>
+            <left_val>3.2730078697204590e-001</left_val>
+            <right_val>-7.4609941244125366e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 11 2 6 -1.</_>
+                <_>
+                  7 11 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5595999546349049e-002</threshold>
+            <left_val>-3.6050570011138916e-001</left_val>
+            <right_val>1.9414800405502319e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 6 4 -1.</_>
+                <_>
+                  6 10 2 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.5029867982957512e-005</threshold>
+            <left_val>3.4985640645027161e-001</left_val>
+            <right_val>-5.5353438854217529e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 8 2 -1.</_>
+                <_>
+                  2 1 8 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.0799087299965322e-005</threshold>
+            <left_val>-4.1298541426658630e-001</left_val>
+            <right_val>2.9194280505180359e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 3 7 -1.</_>
+                <_>
+                  1 3 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7670560628175735e-002</threshold>
+            <left_val>5.6811487674713135e-001</left_val>
+            <right_val>-3.0118390917778015e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 1 4 8 -1.</_>
+                <_>
+                  8 5 4 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.2467430941760540e-003</threshold>
+            <left_val>-3.9970070123672485e-001</left_val>
+            <right_val>2.5405979156494141e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 12 4 -1.</_>
+                <_>
+                  0 17 12 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.7624730137176812e-004</threshold>
+            <left_val>-4.6306419372558594e-001</left_val>
+            <right_val>2.7200910449028015e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 1 3 8 -1.</_>
+                <_>
+                  8 5 3 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.6283427188172936e-004</threshold>
+            <left_val>4.7710940241813660e-001</left_val>
+            <right_val>-2.8456479310989380e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 1 1 8 -1.</_>
+                <_>
+                  3 5 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4720909247407690e-005</threshold>
+            <left_val>-5.9415602684020996e-001</left_val>
+            <right_val>2.8456559777259827e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 1 8 -1.</_>
+                <_>
+                  6 2 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.8523961342871189e-005</threshold>
+            <left_val>1.8699720501899719e-001</left_val>
+            <right_val>-2.9498028755187988e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 2 7 -1.</_>
+                <_>
+                  5 1 1 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3030990269035101e-004</threshold>
+            <left_val>3.1419369578361511e-001</left_val>
+            <right_val>-5.2966248989105225e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 6 3 5 -1.</_>
+                <_>
+                  10 6 1 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2743050465360284e-003</threshold>
+            <left_val>-3.4386789798736572e-001</left_val>
+            <right_val>2.7126389741897583e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 6 -1.</_>
+                <_>
+                  0 15 12 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1066290317103267e-003</threshold>
+            <left_val>-4.5228588581085205e-001</left_val>
+            <right_val>2.4860590696334839e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 10 -1.</_>
+                <_>
+                  6 0 6 5 2.</_>
+                <_>
+                  0 5 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4225989580154419e-003</threshold>
+            <left_val>3.3848088979721069e-001</left_val>
+            <right_val>-4.1214609146118164e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 3 7 -1.</_>
+                <_>
+                  1 4 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8614599481225014e-002</threshold>
+            <left_val>-1.9110870361328125e-001</left_val>
+            <right_val>6.4115452766418457e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 2 8 2 -1.</_>
+                <_>
+                  2 3 8 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.5832890464225784e-005</threshold>
+            <left_val>-5.8493572473526001e-001</left_val>
+            <right_val>2.5314238667488098e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 1 1 6 -1.</_>
+                <_>
+                  5 3 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.9875287560280412e-005</threshold>
+            <left_val>3.6051398515701294e-001</left_val>
+            <right_val>-5.3231191635131836e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 4 7 -1.</_>
+                <_>
+                  7 5 2 7 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1277929879724979e-002</threshold>
+            <left_val>2.7766379714012146e-001</left_val>
+            <right_val>-2.4176590144634247e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 3 -1.</_>
+                <_>
+                  6 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5279600024223328e-001</threshold>
+            <left_val>8.3433318138122559e-001</left_val>
+            <right_val>-1.8692030012607574e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 10 8 10 -1.</_>
+                <_>
+                  6 10 4 5 2.</_>
+                <_>
+                  2 15 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.6294270306825638e-002</threshold>
+            <left_val>3.9919948577880859e-001</left_val>
+            <right_val>-4.1119259595870972e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 2 20 -1.</_>
+                <_>
+                  3 5 2 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5436818152666092e-002</threshold>
+            <left_val>6.8093067407608032e-001</left_val>
+            <right_val>-1.4669400453567505e-001</right_val></_></_></trees>
+      <stage_threshold>-2.0749111175537109e+000</stage_threshold>
+      <parent>4</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 6 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6328740119934082e-001</threshold>
+            <left_val>-6.0435330867767334e-001</left_val>
+            <right_val>5.5052411556243896e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 12 2 -1.</_>
+                <_>
+                  0 4 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.7092619398608804e-005</threshold>
+            <left_val>-9.0228801965713501e-001</left_val>
+            <right_val>2.6281669735908508e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 5 7 6 -1.</_>
+                <_>
+                  1 7 7 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7205731021240354e-004</threshold>
+            <left_val>2.8341010212898254e-001</left_val>
+            <right_val>-8.1372922658920288e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 14 -1.</_>
+                <_>
+                  0 7 12 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8128680530935526e-003</threshold>
+            <left_val>-8.3362382650375366e-001</left_val>
+            <right_val>2.1307690441608429e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 1 2.</_>
+                <_>
+                  6 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.7052993476390839e-003</threshold>
+            <left_val>2.8303650021553040e-001</left_val>
+            <right_val>-7.2392731904983521e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 10 2 4 -1.</_>
+                <_>
+                  10 10 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.6872398999985307e-005</threshold>
+            <left_val>1.3844889402389526e-001</left_val>
+            <right_val>-5.0287842750549316e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 4 2 1 -1.</_>
+                <_>
+                  3 4 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.7435539066791534e-002</threshold>
+            <left_val>-1.0564589872956276e-002</left_val>
+            <right_val>-1.5556719970703125e+003</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 7 2 3 -1.</_>
+                <_>
+                  9 8 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5324270352721214e-002</threshold>
+            <left_val>1.3988590240478516e-001</left_val>
+            <right_val>-6.1316817998886108e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 10 2 -1.</_>
+                <_>
+                  0 1 10 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.1410979330539703e-002</threshold>
+            <left_val>-2.2393199801445007e-001</left_val>
+            <right_val>5.6233572959899902e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 8 5 4 -1.</_>
+                <_>
+                  7 9 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9795040134340525e-004</threshold>
+            <left_val>-2.3459529876708984e-001</left_val>
+            <right_val>1.3877849280834198e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 2 3 -1.</_>
+                <_>
+                  1 8 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.1461639814078808e-003</threshold>
+            <left_val>-8.9666271209716797e-001</left_val>
+            <right_val>1.4354419708251953e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 2 2 -1.</_>
+                <_>
+                  6 16 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.3491749316453934e-002</threshold>
+            <left_val>8.1797057390213013e-001</left_val>
+            <right_val>-8.1737898290157318e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 2 2 -1.</_>
+                <_>
+                  6 16 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.3674921877682209e-003</threshold>
+            <left_val>-6.5259951353073120e-001</left_val>
+            <right_val>1.7211680114269257e-001</right_val></_></_></trees>
+      <stage_threshold>-1.8404649496078491e+000</stage_threshold>
+      <parent>5</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 7 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 16 -1.</_>
+                <_>
+                  2 0 2 16 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.3508180677890778e-002</threshold>
+            <left_val>-4.6614921092987061e-001</left_val>
+            <right_val>5.0694358348846436e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 3 -1.</_>
+                <_>
+                  5 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5386466234922409e-003</threshold>
+            <left_val>-2.4482139945030212e-001</left_val>
+            <right_val>6.0921180248260498e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.2265550494194031e-001</threshold>
+            <left_val>-2.3087610304355621e-001</left_val>
+            <right_val>4.4181710481643677e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 11 6 9 -1.</_>
+                <_>
+                  6 11 3 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.4994042515754700e-002</threshold>
+            <left_val>1.1506160348653793e-001</left_val>
+            <right_val>-5.5417829751968384e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 6 9 -1.</_>
+                <_>
+                  3 11 3 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6755120456218719e-001</threshold>
+            <left_val>7.4653017520904541e-001</left_val>
+            <right_val>-1.3431079685688019e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 3 5 -1.</_>
+                <_>
+                  10 12 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4138720706105232e-002</threshold>
+            <left_val>-4.9592089653015137e-001</left_val>
+            <right_val>6.2578730285167694e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 3 1 -1.</_>
+                <_>
+                  2 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1620320379734039e-002</threshold>
+            <left_val>-1.7977459728717804e-001</left_val>
+            <right_val>5.6873577833175659e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 3 5 -1.</_>
+                <_>
+                  10 12 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.8821419477462769e-002</threshold>
+            <left_val>4.2774148285388947e-002</left_val>
+            <right_val>-6.0440838336944580e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 5 3 -1.</_>
+                <_>
+                  2 12 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.5715501755475998e-002</threshold>
+            <left_val>-2.0169410109519958e-001</left_val>
+            <right_val>5.1855558156967163e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 1 3 -1.</_>
+                <_>
+                  5 7 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7011469230055809e-002</threshold>
+            <left_val>-6.6163742542266846e-001</left_val>
+            <right_val>4.5137479901313782e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 3 1 -1.</_>
+                <_>
+                  7 7 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6027579084038734e-002</threshold>
+            <left_val>5.4205197095870972e-001</left_val>
+            <right_val>-1.8311430513858795e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 9 3 2 -1.</_>
+                <_>
+                  7 10 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.6712950617074966e-003</threshold>
+            <left_val>3.4085698425769806e-002</left_val>
+            <right_val>-3.6544409394264221e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 18 1 2 -1.</_>
+                <_>
+                  1 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0325650218874216e-003</threshold>
+            <left_val>-7.0559221506118774e-001</left_val>
+            <right_val>1.2839829921722412e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 18 1 2 -1.</_>
+                <_>
+                  10 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.7438347721472383e-004</threshold>
+            <left_val>2.0413300395011902e-001</left_val>
+            <right_val>-4.6021059155464172e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 18 1 2 -1.</_>
+                <_>
+                  1 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2579349568113685e-003</threshold>
+            <left_val>1.9696569442749023e-001</left_val>
+            <right_val>-4.9659618735313416e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 9 3 2 -1.</_>
+                <_>
+                  7 10 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3272659629583359e-002</threshold>
+            <left_val>-6.4083862304687500e-001</left_val>
+            <right_val>-1.3145440258085728e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 3 2 -1.</_>
+                <_>
+                  2 10 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8163738101720810e-003</threshold>
+            <left_val>-7.4635922908782959e-001</left_val>
+            <right_val>1.1569319665431976e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 4 3 -1.</_>
+                <_>
+                  8 9 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6880908990278840e-004</threshold>
+            <left_val>-1.7020240426063538e-001</left_val>
+            <right_val>1.0989090055227280e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 4 3 -1.</_>
+                <_>
+                  0 9 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.1302618384361267e-003</threshold>
+            <left_val>-8.6084252595901489e-001</left_val>
+            <right_val>1.0507579892873764e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 8 -1.</_>
+                <_>
+                  0 4 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5290869772434235e-001</threshold>
+            <left_val>-3.0442950129508972e-001</left_val>
+            <right_val>2.9691061377525330e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3563539981842041e+000</stage_threshold>
+      <parent>6</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 8 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 8 11 -1.</_>
+                <_>
+                  2 4 4 11 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0870260000228882e-001</threshold>
+            <left_val>-3.9208391308784485e-001</left_val>
+            <right_val>4.2441639304161072e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 1 3 -1.</_>
+                <_>
+                  9 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.5436011431738734e-005</threshold>
+            <left_val>1.1648490279912949e-001</left_val>
+            <right_val>-1.2261509895324707e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 2 3 -1.</_>
+                <_>
+                  1 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.7897274643182755e-003</threshold>
+            <left_val>-2.2223709523677826e-001</left_val>
+            <right_val>5.8239942789077759e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 1 2.</_>
+                <_>
+                  0 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9092390313744545e-002</threshold>
+            <left_val>-2.8222650289535522e-001</left_val>
+            <right_val>3.4780630469322205e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4692190103232861e-002</threshold>
+            <left_val>2.4436180293560028e-001</left_val>
+            <right_val>-4.4442260265350342e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 12 2 6 -1.</_>
+                <_>
+                  10 12 1 6 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7424240708351135e-002</threshold>
+            <left_val>3.9642699062824249e-002</left_val>
+            <right_val>-5.0866502523422241e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 6 2 -1.</_>
+                <_>
+                  2 12 6 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.9210886955261230e-002</threshold>
+            <left_val>-1.5061080455780029e-001</left_val>
+            <right_val>5.4918211698532104e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 8 5 -1.</_>
+                <_>
+                  4 14 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1516460031270981e-001</threshold>
+            <left_val>4.7058542259037495e-003</left_val>
+            <right_val>-6.0872167348861694e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 15 8 3 -1.</_>
+                <_>
+                  4 15 4 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.0783968567848206e-002</threshold>
+            <left_val>7.6661890745162964e-001</left_val>
+            <right_val>-1.1532770097255707e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 6 6 -1.</_>
+                <_>
+                  8 9 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.3459866940975189e-002</threshold>
+            <left_val>7.7324211597442627e-002</left_val>
+            <right_val>-7.2869849205017090e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 6 6 -1.</_>
+                <_>
+                  4 9 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4063410460948944e-001</threshold>
+            <left_val>-3.0280780792236328e-001</left_val>
+            <right_val>2.9996991157531738e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 2 4 -1.</_>
+                <_>
+                  5 5 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5702848844230175e-003</threshold>
+            <left_val>-2.5590381026268005e-001</left_val>
+            <right_val>3.4416630864143372e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 3 3 -1.</_>
+                <_>
+                  0 9 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.1542655825614929e-003</threshold>
+            <left_val>1.2018810212612152e-001</left_val>
+            <right_val>-8.5254168510437012e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 15 2 3 -1.</_>
+                <_>
+                  7 16 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.7357666343450546e-003</threshold>
+            <left_val>-1.2177339941263199e-001</left_val>
+            <right_val>8.2226127386093140e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 15 3 2 -1.</_>
+                <_>
+                  5 16 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.9444780237972736e-003</threshold>
+            <left_val>-6.1111962795257568e-001</left_val>
+            <right_val>1.3486449420452118e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 14 3 3 -1.</_>
+                <_>
+                  8 15 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.3000229634344578e-003</threshold>
+            <left_val>-3.4730020165443420e-001</left_val>
+            <right_val>4.4554490596055984e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 5 3 -1.</_>
+                <_>
+                  2 13 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.0720161050558090e-002</threshold>
+            <left_val>-1.2618629634380341e-001</left_val>
+            <right_val>6.0286152362823486e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 2 -1.</_>
+                <_>
+                  3 0 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0009969584643841e-002</threshold>
+            <left_val>-4.5014089345932007e-001</left_val>
+            <right_val>1.8092009425163269e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 3 4 -1.</_>
+                <_>
+                  0 10 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1742020025849342e-002</threshold>
+            <left_val>8.1721372902393341e-002</left_val>
+            <right_val>-8.0739098787307739e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 4 6 -1.</_>
+                <_>
+                  8 12 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.7789859864860773e-004</threshold>
+            <left_val>6.6041916608810425e-002</left_val>
+            <right_val>-1.4142000675201416e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 4 6 -1.</_>
+                <_>
+                  0 12 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.4487970173358917e-002</threshold>
+            <left_val>1.0488150268793106e-001</left_val>
+            <right_val>-7.1635431051254272e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 3 -1.</_>
+                <_>
+                  5 6 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4215620011091232e-002</threshold>
+            <left_val>-5.9454482793807983e-001</left_val>
+            <right_val>1.2400969862937927e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 2 -1.</_>
+                <_>
+                  7 6 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.7082370370626450e-002</threshold>
+            <left_val>6.5830427408218384e-001</left_val>
+            <right_val>-1.2158200144767761e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 8 1 -1.</_>
+                <_>
+                  2 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3632909655570984e-003</threshold>
+            <left_val>-6.5290719270706177e-001</left_val>
+            <right_val>1.2228529900312424e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 3 2 -1.</_>
+                <_>
+                  0 6 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.1692638769745827e-003</threshold>
+            <left_val>-7.3107779026031494e-001</left_val>
+            <right_val>7.7946297824382782e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 14 2 3 -1.</_>
+                <_>
+                  7 15 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.0636870563030243e-002</threshold>
+            <left_val>-1.3061979785561562e-002</left_val>
+            <right_val>-8.0408149957656860e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 3 2 -1.</_>
+                <_>
+                  5 15 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5371589921414852e-002</threshold>
+            <left_val>7.9872779548168182e-002</left_val>
+            <right_val>-8.5363340377807617e-001</right_val></_></_></trees>
+      <stage_threshold>-1.4800649881362915e+000</stage_threshold>
+      <parent>7</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 9 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 3 8 -1.</_>
+                <_>
+                  3 4 3 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5033720061182976e-002</threshold>
+            <left_val>-5.3333657979965210e-001</left_val>
+            <right_val>3.4096190333366394e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 7 8 12 -1.</_>
+                <_>
+                  7 7 4 6 2.</_>
+                <_>
+                  3 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.9624240994453430e-002</threshold>
+            <left_val>1.8991500139236450e-001</left_val>
+            <right_val>-2.1448349952697754e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 4 3 -1.</_>
+                <_>
+                  4 7 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.1495251245796680e-003</threshold>
+            <left_val>3.6764401197433472e-001</left_val>
+            <right_val>-3.1621339917182922e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 6 8 -1.</_>
+                <_>
+                  3 13 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.6887358427047729e-002</threshold>
+            <left_val>-2.7120190858840942e-001</left_val>
+            <right_val>3.4590399265289307e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 2 6 -1.</_>
+                <_>
+                  6 12 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2673810124397278e-001</threshold>
+            <left_val>8.4647309780120850e-001</left_val>
+            <right_val>-6.7630723118782043e-002</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 3 8 16 -1.</_>
+                <_>
+                  8 3 4 8 2.</_>
+                <_>
+                  4 11 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0681120306253433e-001</threshold>
+            <left_val>-2.8982621431350708e-001</left_val>
+            <right_val>8.3181828260421753e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 8 16 -1.</_>
+                <_>
+                  0 2 4 8 2.</_>
+                <_>
+                  4 10 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7475779354572296e-001</threshold>
+            <left_val>-3.5948398709297180e-001</left_val>
+            <right_val>3.1073129177093506e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 2 -1.</_>
+                <_>
+                  9 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4629090912640095e-003</threshold>
+            <left_val>-6.7824071645736694e-001</left_val>
+            <right_val>1.1908339709043503e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 2 -1.</_>
+                <_>
+                  0 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.6053359769284725e-003</threshold>
+            <left_val>-2.4560730159282684e-001</left_val>
+            <right_val>3.7791371345520020e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 6 1 2 -1.</_>
+                <_>
+                  9 6 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0148379806196317e-004</threshold>
+            <left_val>-1.0097169876098633e-001</left_val>
+            <right_val>8.2711093127727509e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 12 2 -1.</_>
+                <_>
+                  4 1 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8523789942264557e-002</threshold>
+            <left_val>-4.4592261314392090e-001</left_val>
+            <right_val>1.6946080327033997e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 4 3 5 -1.</_>
+                <_>
+                  10 4 1 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.6602010950446129e-003</threshold>
+            <left_val>-1.0477670282125473e-001</left_val>
+            <right_val>9.4992779195308685e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 4 6 -1.</_>
+                <_>
+                  1 3 2 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0257829912006855e-002</threshold>
+            <left_val>4.3351659178733826e-001</left_val>
+            <right_val>-1.6978879272937775e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 17 1 2 -1.</_>
+                <_>
+                  11 18 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.8685777629725635e-005</threshold>
+            <left_val>1.7843760550022125e-001</left_val>
+            <right_val>-2.6428279280662537e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 1 2 -1.</_>
+                <_>
+                  0 18 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2446290347725153e-003</threshold>
+            <left_val>-7.2253531217575073e-001</left_val>
+            <right_val>1.0615690052509308e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 17 1 3 -1.</_>
+                <_>
+                  11 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1974680091952905e-004</threshold>
+            <left_val>-3.0318620800971985e-001</left_val>
+            <right_val>1.4623160660266876e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 1 3 -1.</_>
+                <_>
+                  0 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2079760199412704e-003</threshold>
+            <left_val>1.3531659543514252e-001</left_val>
+            <right_val>-5.0457692146301270e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 12 12 -1.</_>
+                <_>
+                  0 8 12 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9425910711288452e-001</threshold>
+            <left_val>-7.1733701229095459e-001</left_val>
+            <right_val>8.0573573708534241e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 5 3 6 -1.</_>
+                <_>
+                  2 5 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8599320203065872e-002</threshold>
+            <left_val>-1.6972489655017853e-001</left_val>
+            <right_val>4.2669999599456787e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  5 5 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.0704800039529800e-002</threshold>
+            <left_val>3.2838109880685806e-002</left_val>
+            <right_val>-7.2923952341079712e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  7 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.1680949255824089e-002</threshold>
+            <left_val>-1.6750890016555786e-001</left_val>
+            <right_val>4.4789049029350281e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 3 -1.</_>
+                <_>
+                  10 5 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5604660883545876e-003</threshold>
+            <left_val>9.6391409635543823e-002</left_val>
+            <right_val>-6.6830247640609741e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 2 3 -1.</_>
+                <_>
+                  0 5 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.6784078478813171e-003</threshold>
+            <left_val>-8.2064878940582275e-001</left_val>
+            <right_val>6.2949016690254211e-002</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 3 -1.</_>
+                <_>
+                  8 11 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.0219739302992821e-002</threshold>
+            <left_val>3.3288109302520752e-001</left_val>
+            <right_val>-8.1444039940834045e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 3 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4341929703950882e-002</threshold>
+            <left_val>9.3220241367816925e-002</left_val>
+            <right_val>-6.9502758979797363e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3590339422225952e+000</stage_threshold>
+      <parent>8</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 10 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 4 2 -1.</_>
+                <_>
+                  3 2 2 1 2.</_>
+                <_>
+                  5 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9169401861727238e-003</threshold>
+            <left_val>4.5325928926467896e-001</left_val>
+            <right_val>-3.0284589529037476e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  8 10 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0800900310277939e-001</threshold>
+            <left_val>3.6738589406013489e-002</left_val>
+            <right_val>-7.2782218456268311e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  4 10 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5356090664863586e-001</threshold>
+            <left_val>-3.8900190591812134e-001</left_val>
+            <right_val>3.1287321448326111e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 1 6 -1.</_>
+                <_>
+                  4 6 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.7726805359125137e-003</threshold>
+            <left_val>-1.5705280005931854e-001</left_val>
+            <right_val>8.2666940987110138e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 6 1 -1.</_>
+                <_>
+                  8 6 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0571720078587532e-002</threshold>
+            <left_val>2.4971100687980652e-001</left_val>
+            <right_val>-4.7014111280441284e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  5 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.7240550145506859e-002</threshold>
+            <left_val>6.0097638517618179e-002</left_val>
+            <right_val>-6.6213667392730713e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  7 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.6633450537919998e-002</threshold>
+            <left_val>5.1044297218322754e-001</left_val>
+            <right_val>-1.7766149342060089e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 16 10 4 -1.</_>
+                <_>
+                  2 16 5 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3806289434432983e-001</threshold>
+            <left_val>-4.0644191205501556e-002</left_val>
+            <right_val>7.8849452733993530e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 10 -1.</_>
+                <_>
+                  0 5 12 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.4720393419265747e-002</threshold>
+            <left_val>-4.3654170632362366e-001</left_val>
+            <right_val>1.9054649770259857e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 2 -1.</_>
+                <_>
+                  10 0 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.3387150615453720e-003</threshold>
+            <left_val>-6.8457669019699097e-001</left_val>
+            <right_val>9.6802540123462677e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 2 -1.</_>
+                <_>
+                  1 0 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1899480159627274e-004</threshold>
+            <left_val>-3.5843661427497864e-001</left_val>
+            <right_val>2.2279889881610870e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 15 2 2 -1.</_>
+                <_>
+                  7 15 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.9007149860262871e-003</threshold>
+            <left_val>-1.5845039486885071e-001</left_val>
+            <right_val>6.6679857671260834e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 2 6 -1.</_>
+                <_>
+                  0 8 1 3 2.</_>
+                <_>
+                  1 11 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2376639991998672e-002</threshold>
+            <left_val>-1.4206279814243317e-001</left_val>
+            <right_val>4.9320921301841736e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 11 2 4 -1.</_>
+                <_>
+                  9 12 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.0215988196432590e-003</threshold>
+            <left_val>-1.4971609413623810e-001</left_val>
+            <right_val>2.1797719597816467e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 10 4 -1.</_>
+                <_>
+                  5 16 5 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6887940466403961e-001</threshold>
+            <left_val>7.1833407878875732e-001</left_val>
+            <right_val>-1.1091569811105728e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 18 10 2 -1.</_>
+                <_>
+                  1 19 10 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.4033271521329880e-003</threshold>
+            <left_val>2.2573550045490265e-001</left_val>
+            <right_val>-3.2993030548095703e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 4 -1.</_>
+                <_>
+                  0 9 1 2 2.</_>
+                <_>
+                  1 11 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.5029351972043514e-003</threshold>
+            <left_val>4.7018998861312866e-001</left_val>
+            <right_val>-1.5201370418071747e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 3 3 -1.</_>
+                <_>
+                  8 13 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7706790240481496e-003</threshold>
+            <left_val>-1.4644999802112579e-001</left_val>
+            <right_val>9.4745017588138580e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 3 -1.</_>
+                <_>
+                  4 13 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7085459083318710e-002</threshold>
+            <left_val>8.5357367992401123e-002</left_val>
+            <right_val>-8.2599818706512451e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  5 5 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.3032718598842621e-002</threshold>
+            <left_val>-6.5861982107162476e-001</left_val>
+            <right_val>-1.3727230252698064e-003</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  7 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.7725089341402054e-002</threshold>
+            <left_val>-1.4935420453548431e-001</left_val>
+            <right_val>4.4009518623352051e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 3 3 -1.</_>
+                <_>
+                  8 13 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.8685488998889923e-002</threshold>
+            <left_val>7.8679984435439110e-003</left_val>
+            <right_val>-4.4109138846397400e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 3 -1.</_>
+                <_>
+                  4 13 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0465820319950581e-002</threshold>
+            <left_val>-5.8385229110717773e-001</left_val>
+            <right_val>1.0567150264978409e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  5 5 3 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.4063638895750046e-002</threshold>
+            <left_val>-5.9246909618377686e-001</left_val>
+            <right_val>5.7151052169501781e-003</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  7 5 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1932180263102055e-002</threshold>
+            <left_val>2.3818169534206390e-001</left_val>
+            <right_val>-2.8293299674987793e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 18 2 2 -1.</_>
+                <_>
+                  9 19 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2644910020753741e-003</threshold>
+            <left_val>1.0124749690294266e-001</left_val>
+            <right_val>-3.3939999341964722e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 18 2 2 -1.</_>
+                <_>
+                  1 19 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8404610455036163e-003</threshold>
+            <left_val>-6.7492902278900146e-001</left_val>
+            <right_val>9.5524467527866364e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 6 2 3 -1.</_>
+                <_>
+                  10 7 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.9289656132459641e-003</threshold>
+            <left_val>-6.7770427465438843e-001</left_val>
+            <right_val>3.4221731126308441e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 4 -1.</_>
+                <_>
+                  0 1 1 2 2.</_>
+                <_>
+                  1 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.7004559785127640e-003</threshold>
+            <left_val>-1.3198739290237427e-001</left_val>
+            <right_val>4.2710319161415100e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 2 3 -1.</_>
+                <_>
+                  6 0 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8237680196762085e-002</threshold>
+            <left_val>3.0692299827933311e-002</left_val>
+            <right_val>-8.6847299337387085e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 13 2 2 -1.</_>
+                <_>
+                  2 13 1 1 2.</_>
+                <_>
+                  3 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.2086670398712158e-003</threshold>
+            <left_val>-1.3335919380187988e-001</left_val>
+            <right_val>4.3883138895034790e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 6 2 3 -1.</_>
+                <_>
+                  10 7 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2446580454707146e-002</threshold>
+            <left_val>2.9371360316872597e-002</left_val>
+            <right_val>-7.8926819562911987e-001</right_val></_></_></trees>
+      <stage_threshold>-1.4373550415039062e+000</stage_threshold>
+      <parent>9</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 11 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 1 4 3 -1.</_>
+                <_>
+                  2 2 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2674730271100998e-002</threshold>
+            <left_val>5.0484418869018555e-001</left_val>
+            <right_val>-2.5669950246810913e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 4 3 3 -1.</_>
+                <_>
+                  6 5 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1808129958808422e-002</threshold>
+            <left_val>6.3001699745655060e-002</left_val>
+            <right_val>-4.0641498565673828e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 2 2 -1.</_>
+                <_>
+                  5 5 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5127220433205366e-003</threshold>
+            <left_val>-3.2253271341323853e-001</left_val>
+            <right_val>3.6614939570426941e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 10 2 6 -1.</_>
+                <_>
+                  10 10 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.5469220019876957e-003</threshold>
+            <left_val>1.9579920172691345e-001</left_val>
+            <right_val>-1.5416850149631500e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 4 4 -1.</_>
+                <_>
+                  2 12 2 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9148680865764618e-002</threshold>
+            <left_val>-2.5791868567466736e-001</left_val>
+            <right_val>3.3852350711822510e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3151739537715912e-001</threshold>
+            <left_val>2.7472509071230888e-002</left_val>
+            <right_val>-5.5891007184982300e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6689460724592209e-002</threshold>
+            <left_val>1.4658740162849426e-001</left_val>
+            <right_val>-5.2727991342544556e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 2 3 -1.</_>
+                <_>
+                  8 13 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.4351540058851242e-003</threshold>
+            <left_val>-1.2016840279102325e-001</left_val>
+            <right_val>1.8379710614681244e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 1 6 -1.</_>
+                <_>
+                  6 12 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.3846178352832794e-002</threshold>
+            <left_val>7.5390338897705078e-001</left_val>
+            <right_val>-1.0603629797697067e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 16 3 2 -1.</_>
+                <_>
+                  5 17 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.6943090856075287e-003</threshold>
+            <left_val>2.0730340480804443e-001</left_val>
+            <right_val>-1.6408169269561768e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 2 -1.</_>
+                <_>
+                  4 13 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1263520456850529e-002</threshold>
+            <left_val>1.0285060107707977e-001</left_val>
+            <right_val>-7.2724348306655884e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0440419428050518e-003</threshold>
+            <left_val>1.3197229802608490e-001</left_val>
+            <right_val>-6.4476031064987183e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 11 -1.</_>
+                <_>
+                  2 0 2 11 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9053710401058197e-002</threshold>
+            <left_val>-3.2099440693855286e-001</left_val>
+            <right_val>1.9499249756336212e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 11 2 3 -1.</_>
+                <_>
+                  9 12 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2985640205442905e-002</threshold>
+            <left_val>-6.2498811632394791e-002</left_val>
+            <right_val>2.6551690697669983e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 11 3 2 -1.</_>
+                <_>
+                  3 12 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4938330277800560e-002</threshold>
+            <left_val>8.0150052905082703e-002</left_val>
+            <right_val>-7.6676148176193237e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 3 5 -1.</_>
+                <_>
+                  10 12 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.4180350601673126e-002</threshold>
+            <left_val>-5.1320338249206543e-001</left_val>
+            <right_val>-3.6074419040232897e-003</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 5 3 -1.</_>
+                <_>
+                  2 12 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.3761111795902252e-002</threshold>
+            <left_val>-1.4384460449218750e-001</left_val>
+            <right_val>4.2616510391235352e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 4 2 -1.</_>
+                <_>
+                  8 13 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1876770295202732e-003</threshold>
+            <left_val>1.4837500452995300e-001</left_val>
+            <right_val>-5.0197489559650421e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 4 2 -1.</_>
+                <_>
+                  0 13 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3196719810366631e-002</threshold>
+            <left_val>-7.6232409477233887e-001</left_val>
+            <right_val>7.9683482646942139e-002</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 2 2 -1.</_>
+                <_>
+                  9 13 1 1 2.</_>
+                <_>
+                  8 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4940570108592510e-003</threshold>
+            <left_val>2.2585479915142059e-001</left_val>
+            <right_val>-1.0884329676628113e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 5 3 -1.</_>
+                <_>
+                  0 8 5 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.9800303578376770e-003</threshold>
+            <left_val>7.7047176659107208e-002</left_val>
+            <right_val>-8.1608718633651733e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 2 2 -1.</_>
+                <_>
+                  9 13 1 1 2.</_>
+                <_>
+                  8 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3630810426548123e-003</threshold>
+            <left_val>-1.0334450006484985e-001</left_val>
+            <right_val>2.0994339883327484e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 13 2 2 -1.</_>
+                <_>
+                  2 13 1 1 2.</_>
+                <_>
+                  3 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.6497698854655027e-003</threshold>
+            <left_val>4.8666700720787048e-001</left_val>
+            <right_val>-1.2183590233325958e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 8 5 4 -1.</_>
+                <_>
+                  7 9 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9017059132456779e-002</threshold>
+            <left_val>3.0331170186400414e-002</left_val>
+            <right_val>-5.4417270421981812e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 2 8 -1.</_>
+                <_>
+                  0 5 1 4 2.</_>
+                <_>
+                  1 9 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7291629686951637e-002</threshold>
+            <left_val>-1.3578090071678162e-001</left_val>
+            <right_val>4.4251319766044617e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 4 -1.</_>
+                <_>
+                  8 9 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9144080579280853e-003</threshold>
+            <left_val>-8.2041606307029724e-002</left_val>
+            <right_val>1.1203309893608093e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 3 4 -1.</_>
+                <_>
+                  1 9 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.2138089239597321e-003</threshold>
+            <left_val>9.5674678683280945e-002</left_val>
+            <right_val>-7.1387839317321777e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 16 -1.</_>
+                <_>
+                  0 8 12 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9401769340038300e-001</threshold>
+            <left_val>-3.3527439832687378e-001</left_val>
+            <right_val>1.6470989584922791e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 2 -1.</_>
+                <_>
+                  0 0 2 1 2.</_>
+                <_>
+                  2 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.9092198759317398e-003</threshold>
+            <left_val>4.5958560705184937e-001</left_val>
+            <right_val>-1.3180640339851379e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 3 3 -1.</_>
+                <_>
+                  8 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6158509999513626e-002</threshold>
+            <left_val>-8.8425397872924805e-001</left_val>
+            <right_val>3.6370448768138885e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 5 3 -1.</_>
+                <_>
+                  2 13 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.3315120041370392e-002</threshold>
+            <left_val>3.5693758726119995e-001</left_val>
+            <right_val>-1.4853119850158691e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 12 4 -1.</_>
+                <_>
+                  3 8 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.0759939253330231e-002</threshold>
+            <left_val>3.1768760085105896e-001</left_val>
+            <right_val>-1.8056009709835052e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 2 2 -1.</_>
+                <_>
+                  2 12 1 1 2.</_>
+                <_>
+                  3 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8645009733736515e-003</threshold>
+            <left_val>5.3059607744216919e-001</left_val>
+            <right_val>-1.1261919885873795e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 15 2 3 -1.</_>
+                <_>
+                  10 16 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1360960081219673e-002</threshold>
+            <left_val>3.5099871456623077e-002</left_val>
+            <right_val>-4.7815018892288208e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3898090124130249e+000</stage_threshold>
+      <parent>10</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 12 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 8 1 -1.</_>
+                <_>
+                  2 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3970459811389446e-002</threshold>
+            <left_val>-3.0530300736427307e-001</left_val>
+            <right_val>4.1125300526618958e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 8 12 -1.</_>
+                <_>
+                  7 6 4 6 2.</_>
+                <_>
+                  3 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1679069697856903e-001</threshold>
+            <left_val>1.4812999963760376e-001</left_val>
+            <right_val>-7.0709809660911560e-002</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 3 3 -1.</_>
+                <_>
+                  6 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.6397690400481224e-002</threshold>
+            <left_val>-3.0543169379234314e-001</left_val>
+            <right_val>3.0162781476974487e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 8 12 -1.</_>
+                <_>
+                  8 6 4 6 2.</_>
+                <_>
+                  4 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0286109298467636e-002</threshold>
+            <left_val>-2.3618179559707642e-001</left_val>
+            <right_val>1.2187310308218002e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 10 14 -1.</_>
+                <_>
+                  0 5 5 7 2.</_>
+                <_>
+                  5 12 5 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.3962181210517883e-001</threshold>
+            <left_val>-2.3415289819240570e-001</left_val>
+            <right_val>3.7955328822135925e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 2 10 4 -1.</_>
+                <_>
+                  1 4 10 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.0632884055376053e-003</threshold>
+            <left_val>-5.6521987915039063e-001</left_val>
+            <right_val>1.2719720602035522e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 15 1 2 -1.</_>
+                <_>
+                  0 16 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4234139816835523e-003</threshold>
+            <left_val>-5.8998572826385498e-001</left_val>
+            <right_val>1.1668500304222107e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 4 3 -1.</_>
+                <_>
+                  6 1 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9983680471777916e-003</threshold>
+            <left_val>-9.9398262798786163e-002</left_val>
+            <right_val>1.2795600295066833e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 14 2 2 -1.</_>
+                <_>
+                  5 14 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.4549506902694702e-003</threshold>
+            <left_val>-5.6156420707702637e-001</left_val>
+            <right_val>9.9381953477859497e-002</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 1 -1.</_>
+                <_>
+                  0 9 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7270709872245789e-002</threshold>
+            <left_val>8.4691196680068970e-002</left_val>
+            <right_val>-6.5302717685699463e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 3 3 -1.</_>
+                <_>
+                  0 6 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.1806071102619171e-003</threshold>
+            <left_val>6.4047202467918396e-002</left_val>
+            <right_val>-7.3235487937927246e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 4 3 -1.</_>
+                <_>
+                  7 13 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.7418292164802551e-002</threshold>
+            <left_val>4.3028471991419792e-003</left_val>
+            <right_val>-6.2574678659439087e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 12 3 4 -1.</_>
+                <_>
+                  5 13 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.8985599279403687e-002</threshold>
+            <left_val>7.0422857999801636e-002</left_val>
+            <right_val>-7.7566891908645630e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 2 3 -1.</_>
+                <_>
+                  7 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.0685300589539111e-004</threshold>
+            <left_val>6.0799881815910339e-002</left_val>
+            <right_val>-7.3534972965717316e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 2 3 -1.</_>
+                <_>
+                  3 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0786009952425957e-002</threshold>
+            <left_val>-1.2505950033664703e-001</left_val>
+            <right_val>4.8208248615264893e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 2 -1.</_>
+                <_>
+                  10 0 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.9674388505518436e-003</threshold>
+            <left_val>8.3264723420143127e-002</left_val>
+            <right_val>-6.9356048107147217e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 2 2 -1.</_>
+                <_>
+                  2 0 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2767270207405090e-002</threshold>
+            <left_val>6.4788013696670532e-002</left_val>
+            <right_val>-7.0968890190124512e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 1 -1.</_>
+                <_>
+                  10 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4131699688732624e-002</threshold>
+            <left_val>-7.5622642040252686e-001</left_val>
+            <right_val>2.0618569105863571e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 1 2.</_>
+                <_>
+                  6 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5918679535388947e-002</threshold>
+            <left_val>1.9603510200977325e-001</left_val>
+            <right_val>-2.7034899592399597e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 8 10 -1.</_>
+                <_>
+                  2 12 8 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.9455211311578751e-003</threshold>
+            <left_val>-4.3780571222305298e-001</left_val>
+            <right_val>1.1859329789876938e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 10 -1.</_>
+                <_>
+                  1 9 1 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5286459587514400e-002</threshold>
+            <left_val>-1.9513919949531555e-001</left_val>
+            <right_val>2.6915138959884644e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 9 3 2 -1.</_>
+                <_>
+                  10 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9025101363658905e-003</threshold>
+            <left_val>-1.6288129985332489e-001</left_val>
+            <right_val>3.6743709444999695e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 3 2 -1.</_>
+                <_>
+                  1 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.9729480892419815e-003</threshold>
+            <left_val>4.6202778816223145e-001</left_val>
+            <right_val>-1.5376560389995575e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 6 4 3 -1.</_>
+                <_>
+                  8 7 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9449390470981598e-002</threshold>
+            <left_val>-5.3632599115371704e-001</left_val>
+            <right_val>3.1576488167047501e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 2 3 -1.</_>
+                <_>
+                  0 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.7259521670639515e-003</threshold>
+            <left_val>-7.3517972230911255e-001</left_val>
+            <right_val>7.3678806424140930e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 3 -1.</_>
+                <_>
+                  9 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.5517195984721184e-003</threshold>
+            <left_val>3.5986369848251343e-001</left_val>
+            <right_val>-1.2420760095119476e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 4 12 -1.</_>
+                <_>
+                  2 8 2 12 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.8964512348175049e-002</threshold>
+            <left_val>6.2507808208465576e-001</left_val>
+            <right_val>-8.6647883057594299e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 1 3 -1.</_>
+                <_>
+                  5 8 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7731260508298874e-002</threshold>
+            <left_val>-5.7925891876220703e-001</left_val>
+            <right_val>2.5198649615049362e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  7 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.9190430417656898e-002</threshold>
+            <left_val>5.7298821210861206e-001</left_val>
+            <right_val>-1.0151000320911407e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 1 -1.</_>
+                <_>
+                  10 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.4621109738945961e-003</threshold>
+            <left_val>4.4515479356050491e-002</left_val>
+            <right_val>-6.6922581195831299e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 1 2 -1.</_>
+                <_>
+                  2 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.8695018999278545e-003</threshold>
+            <left_val>-5.8384990692138672e-001</left_val>
+            <right_val>8.7239846587181091e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 1 -1.</_>
+                <_>
+                  10 10 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7049070447683334e-003</threshold>
+            <left_val>2.2694580256938934e-001</left_val>
+            <right_val>-8.1620521843433380e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 3 1 -1.</_>
+                <_>
+                  1 10 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.8957659639418125e-003</threshold>
+            <left_val>-1.1778759956359863e-001</left_val>
+            <right_val>4.2724978923797607e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 12 2 3 -1.</_>
+                <_>
+                  9 13 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.5842777043581009e-003</threshold>
+            <left_val>-5.4629139602184296e-002</left_val>
+            <right_val>1.0813979804515839e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 3 2 -1.</_>
+                <_>
+                  3 13 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2934260070323944e-002</threshold>
+            <left_val>7.0849359035491943e-002</left_val>
+            <right_val>-7.3857682943344116e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 3 -1.</_>
+                <_>
+                  9 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9973270595073700e-002</threshold>
+            <left_val>1.6626559663563967e-003</left_val>
+            <right_val>-7.6631492376327515e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 3 3 -1.</_>
+                <_>
+                  0 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5011189542710781e-003</threshold>
+            <left_val>8.9468717575073242e-002</left_val>
+            <right_val>-5.3985279798507690e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3544019460678101e+000</stage_threshold>
+      <parent>11</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 13 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 2 -1.</_>
+                <_>
+                  0 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.9501233994960785e-003</threshold>
+            <left_val>-2.7952459454536438e-001</left_val>
+            <right_val>4.3506631255149841e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 2 -1.</_>
+                <_>
+                  6 0 3 1 2.</_>
+                <_>
+                  3 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5085919760167599e-002</threshold>
+            <left_val>5.9209001064300537e-001</left_val>
+            <right_val>-1.6481369733810425e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 8 12 -1.</_>
+                <_>
+                  1 7 4 6 2.</_>
+                <_>
+                  5 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9475109875202179e-001</threshold>
+            <left_val>-3.1889539957046509e-001</left_val>
+            <right_val>2.8196701407432556e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 6 4 1 -1.</_>
+                <_>
+                  7 6 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4689928977750242e-004</threshold>
+            <left_val>9.6763692796230316e-002</left_val>
+            <right_val>-1.8406489491462708e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 2 -1.</_>
+                <_>
+                  6 0 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.2499058656394482e-003</threshold>
+            <left_val>1.5704880654811859e-001</left_val>
+            <right_val>-5.2710950374603271e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 2 1 4 -1.</_>
+                <_>
+                  10 2 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2732569302897900e-004</threshold>
+            <left_val>5.3218118846416473e-002</left_val>
+            <right_val>-1.6152860224246979e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 2 4 1 -1.</_>
+                <_>
+                  2 2 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.5984549000859261e-003</threshold>
+            <left_val>2.1844869852066040e-001</left_val>
+            <right_val>-3.7529769539833069e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 15 8 4 -1.</_>
+                <_>
+                  4 15 4 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2836559675633907e-002</threshold>
+            <left_val>6.1008229851722717e-002</left_val>
+            <right_val>-1.1862020194530487e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 8 5 -1.</_>
+                <_>
+                  4 14 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4707820117473602e-001</threshold>
+            <left_val>7.9065358638763428e-001</left_val>
+            <right_val>-9.4447426497936249e-002</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 4 5 -1.</_>
+                <_>
+                  8 12 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.8533070832490921e-002</threshold>
+            <left_val>4.9431171268224716e-002</left_val>
+            <right_val>-5.9807902574539185e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 4 7 -1.</_>
+                <_>
+                  2 10 2 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.1398849338293076e-002</threshold>
+            <left_val>-3.1118649244308472e-001</left_val>
+            <right_val>2.4850000441074371e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 3 3 -1.</_>
+                <_>
+                  5 1 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9322831220924854e-003</threshold>
+            <left_val>-1.9105120003223419e-001</left_val>
+            <right_val>2.6189088821411133e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 3 1 -1.</_>
+                <_>
+                  7 9 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.1201062053442001e-003</threshold>
+            <left_val>-1.4400300383567810e-001</left_val>
+            <right_val>3.8592028617858887e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 6 3 3 -1.</_>
+                <_>
+                  9 7 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2118129990994930e-002</threshold>
+            <left_val>-5.7840502262115479e-001</left_val>
+            <right_val>3.1328909099102020e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 3 3 -1.</_>
+                <_>
+                  0 7 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5321048498153687e-003</threshold>
+            <left_val>7.6200783252716064e-002</left_val>
+            <right_val>-7.1263229846954346e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 4 2 -1.</_>
+                <_>
+                  8 14 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.4633679836988449e-003</threshold>
+            <left_val>-8.1573672592639923e-002</left_val>
+            <right_val>1.5981380641460419e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 2 3 -1.</_>
+                <_>
+                  0 7 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.4435349777340889e-003</threshold>
+            <left_val>-8.9533412456512451e-001</left_val>
+            <right_val>6.0908339917659760e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 3 -1.</_>
+                <_>
+                  9 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3353319838643074e-002</threshold>
+            <left_val>5.0735729932785034e-001</left_val>
+            <right_val>-1.4220820367336273e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 5 4 -1.</_>
+                <_>
+                  0 14 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8206631094217300e-002</threshold>
+            <left_val>-7.0776158571243286e-001</left_val>
+            <right_val>8.7017923593521118e-002</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 4 2 -1.</_>
+                <_>
+                  8 16 2 1 2.</_>
+                <_>
+                  6 17 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.6862186435610056e-005</threshold>
+            <left_val>9.2491082847118378e-002</left_val>
+            <right_val>-1.9064180552959442e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 12 2 2 -1.</_>
+                <_>
+                  1 12 1 1 2.</_>
+                <_>
+                  2 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5890119615942240e-003</threshold>
+            <left_val>-1.1369240283966064e-001</left_val>
+            <right_val>4.5717659592628479e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 2 2 -1.</_>
+                <_>
+                  9 12 1 1 2.</_>
+                <_>
+                  8 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5103650987148285e-003</threshold>
+            <left_val>-9.6626877784729004e-002</left_val>
+            <right_val>2.8315341472625732e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 1 2 -1.</_>
+                <_>
+                  0 17 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6438219463452697e-003</threshold>
+            <left_val>-6.8512988090515137e-001</left_val>
+            <right_val>8.4855683147907257e-002</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 2 2 -1.</_>
+                <_>
+                  9 12 1 1 2.</_>
+                <_>
+                  8 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1147640179842710e-003</threshold>
+            <left_val>2.0340760052204132e-001</left_val>
+            <right_val>-9.5162183046340942e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 2 2 -1.</_>
+                <_>
+                  2 12 1 1 2.</_>
+                <_>
+                  3 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.3129220828413963e-003</threshold>
+            <left_val>-1.2348870187997818e-001</left_val>
+            <right_val>4.5109578967094421e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 2 3 -1.</_>
+                <_>
+                  7 14 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2473019771277905e-002</threshold>
+            <left_val>8.5647627711296082e-002</left_val>
+            <right_val>-1.7752259969711304e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 13 3 2 -1.</_>
+                <_>
+                  5 14 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1887500062584877e-002</threshold>
+            <left_val>7.9497292637825012e-002</left_val>
+            <right_val>-7.1333557367324829e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 2 4 -1.</_>
+                <_>
+                  10 10 1 2 2.</_>
+                <_>
+                  9 12 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.6640802174806595e-003</threshold>
+            <left_val>-1.1890850216150284e-001</left_val>
+            <right_val>1.6375760734081268e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 10 2 4 -1.</_>
+                <_>
+                  1 10 1 2 2.</_>
+                <_>
+                  2 12 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.5049358420073986e-003</threshold>
+            <left_val>4.5544099807739258e-001</left_val>
+            <right_val>-1.2412810325622559e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 16 2 2 -1.</_>
+                <_>
+                  7 16 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7780659720301628e-002</threshold>
+            <left_val>-1.0757599771022797e-001</left_val>
+            <right_val>1.6240009665489197e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 3 3 -1.</_>
+                <_>
+                  2 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.5337750129401684e-003</threshold>
+            <left_val>4.3141070008277893e-001</left_val>
+            <right_val>-1.2603540718555450e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 3 3 -1.</_>
+                <_>
+                  8 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4446230381727219e-002</threshold>
+            <left_val>-6.6479730606079102e-001</left_val>
+            <right_val>1.9722750410437584e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 3 3 -1.</_>
+                <_>
+                  5 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.8284119479358196e-003</threshold>
+            <left_val>8.7926700711250305e-002</left_val>
+            <right_val>-5.4765981435775757e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 8 4 6 -1.</_>
+                <_>
+                  5 11 4 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7527850344777107e-002</threshold>
+            <left_val>-4.7350269556045532e-001</left_val>
+            <right_val>1.8452549353241920e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 6 1 -1.</_>
+                <_>
+                  6 5 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.6044701486825943e-003</threshold>
+            <left_val>1.6700869798660278e-001</left_val>
+            <right_val>-2.8558060526847839e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 15 2 2 -1.</_>
+                <_>
+                  7 15 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.6587088853120804e-002</threshold>
+            <left_val>9.8792626522481441e-004</left_val>
+            <right_val>-9.0761202573776245e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 15 2 2 -1.</_>
+                <_>
+                  5 15 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.1678956523537636e-003</threshold>
+            <left_val>-5.7369470596313477e-001</left_val>
+            <right_val>8.6971327662467957e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 3 3 3 -1.</_>
+                <_>
+                  9 4 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.9324431717395782e-003</threshold>
+            <left_val>-7.1619319915771484e-001</left_val>
+            <right_val>4.7531701624393463e-002</right_val></_></_></trees>
+      <stage_threshold>-1.3085269927978516e+000</stage_threshold>
+      <parent>12</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 14 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 3 4 -1.</_>
+                <_>
+                  4 5 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1259860359132290e-002</threshold>
+            <left_val>-3.2671540975570679e-001</left_val>
+            <right_val>3.7448620796203613e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.0411562521476299e-005</threshold>
+            <left_val>1.3456510007381439e-001</left_val>
+            <right_val>-3.5597088932991028e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 2 1 -1.</_>
+                <_>
+                  1 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0097360238432884e-002</threshold>
+            <left_val>4.2515400052070618e-001</left_val>
+            <right_val>-2.0356260240077972e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 8 12 -1.</_>
+                <_>
+                  8 6 4 6 2.</_>
+                <_>
+                  4 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.5205657184123993e-002</threshold>
+            <left_val>-2.6214841008186340e-001</left_val>
+            <right_val>4.4497821480035782e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 8 12 -1.</_>
+                <_>
+                  1 6 4 6 2.</_>
+                <_>
+                  5 12 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.1976239979267120e-001</threshold>
+            <left_val>-2.6376900076866150e-001</left_val>
+            <right_val>2.7963450551033020e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 3 -1.</_>
+                <_>
+                  9 1 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4373429585248232e-003</threshold>
+            <left_val>1.9384309649467468e-001</left_val>
+            <right_val>-6.6377736628055573e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 3 2 -1.</_>
+                <_>
+                  3 1 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.1600460633635521e-002</threshold>
+            <left_val>5.2735280990600586e-001</left_val>
+            <right_val>-1.1125139892101288e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 4 3 -1.</_>
+                <_>
+                  7 11 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.8454764336347580e-003</threshold>
+            <left_val>-1.6414600610733032e-001</left_val>
+            <right_val>1.7835170030593872e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 14 -1.</_>
+                <_>
+                  0 7 12 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5627551376819611e-002</threshold>
+            <left_val>-5.0226557254791260e-001</left_val>
+            <right_val>1.2036989629268646e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 1 2.</_>
+                <_>
+                  0 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9948599860072136e-002</threshold>
+            <left_val>-2.4443860352039337e-001</left_val>
+            <right_val>2.0503400266170502e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 2 3 -1.</_>
+                <_>
+                  0 18 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.0674149747937918e-003</threshold>
+            <left_val>-5.3477287292480469e-001</left_val>
+            <right_val>1.1543580144643784e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 8 2 6 -1.</_>
+                <_>
+                  11 8 1 3 2.</_>
+                <_>
+                  10 11 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2012269580736756e-003</threshold>
+            <left_val>1.2676300108432770e-001</left_val>
+            <right_val>-1.3938720524311066e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 2 6 -1.</_>
+                <_>
+                  0 8 1 3 2.</_>
+                <_>
+                  1 11 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7143359407782555e-002</threshold>
+            <left_val>-1.0488930344581604e-001</left_val>
+            <right_val>4.8458871245384216e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 2 3 -1.</_>
+                <_>
+                  10 18 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.7037338633090258e-004</threshold>
+            <left_val>-2.6416009664535522e-001</left_val>
+            <right_val>1.3753029704093933e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 2 3 -1.</_>
+                <_>
+                  0 18 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9928140100091696e-003</threshold>
+            <left_val>1.0820219665765762e-001</left_val>
+            <right_val>-4.6027541160583496e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 8 3 3 -1.</_>
+                <_>
+                  10 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.1858411431312561e-003</threshold>
+            <left_val>-1.1870039999485016e-001</left_val>
+            <right_val>1.8429510295391083e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 3 14 -1.</_>
+                <_>
+                  0 13 3 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0016850531101227e-001</threshold>
+            <left_val>-7.7433213591575623e-002</left_val>
+            <right_val>6.7445492744445801e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 8 3 3 -1.</_>
+                <_>
+                  10 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2134050019085407e-002</threshold>
+            <left_val>4.5361760258674622e-001</left_val>
+            <right_val>-3.2230481505393982e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 3 3 -1.</_>
+                <_>
+                  1 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1809550225734711e-002</threshold>
+            <left_val>-1.5140220522880554e-001</left_val>
+            <right_val>4.1091579198837280e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 9 3 3 -1.</_>
+                <_>
+                  8 10 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.3903311491012573e-002</threshold>
+            <left_val>2.4644249677658081e-001</left_val>
+            <right_val>-1.6336809843778610e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 9 3 3 -1.</_>
+                <_>
+                  4 10 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5369100272655487e-002</threshold>
+            <left_val>5.7606618851423264e-002</left_val>
+            <right_val>-8.1810200214385986e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 7 4 1 -1.</_>
+                <_>
+                  8 7 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.0477071888744831e-003</threshold>
+            <left_val>3.4279700368642807e-002</left_val>
+            <right_val>-3.8912689685821533e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 4 1 -1.</_>
+                <_>
+                  2 7 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3273769766092300e-003</threshold>
+            <left_val>-2.6318120956420898e-001</left_val>
+            <right_val>2.0111019909381866e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 7 -1.</_>
+                <_>
+                  0 0 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4055520296096802e-002</threshold>
+            <left_val>-4.5798641443252563e-001</left_val>
+            <right_val>1.0322000086307526e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 4 3 -1.</_>
+                <_>
+                  2 13 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.1040539741516113e-002</threshold>
+            <left_val>-1.0665339976549149e-001</left_val>
+            <right_val>4.9921628832817078e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 3 3 -1.</_>
+                <_>
+                  8 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7403350211679935e-003</threshold>
+            <left_val>-3.0963689088821411e-002</left_val>
+            <right_val>9.0507246553897858e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 10 3 3 -1.</_>
+                <_>
+                  1 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.9111667796969414e-003</threshold>
+            <left_val>-6.9301342964172363e-001</left_val>
+            <right_val>7.1324340999126434e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  4 15 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.4086872637271881e-002</threshold>
+            <left_val>4.6972590684890747e-001</left_val>
+            <right_val>-4.9859449267387390e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  8 15 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2733220355585217e-003</threshold>
+            <left_val>-3.5704851150512695e-001</left_val>
+            <right_val>1.3806779682636261e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 3 -1.</_>
+                <_>
+                  5 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9486827813088894e-003</threshold>
+            <left_val>-1.5816900134086609e-001</left_val>
+            <right_val>2.8468400239944458e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 3 4 -1.</_>
+                <_>
+                  1 9 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.6815077811479568e-003</threshold>
+            <left_val>-7.6587718725204468e-001</left_val>
+            <right_val>6.2390629202127457e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 2 -1.</_>
+                <_>
+                  10 1 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0674200020730495e-002</threshold>
+            <left_val>-5.5144512653350830e-001</left_val>
+            <right_val>5.6196320801973343e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 2 3 -1.</_>
+                <_>
+                  2 1 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7951499670743942e-002</threshold>
+            <left_val>6.1362300068140030e-002</left_val>
+            <right_val>-6.4841997623443604e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 2 1 -1.</_>
+                <_>
+                  10 17 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9660689576994628e-004</threshold>
+            <left_val>-1.4563970267772675e-001</left_val>
+            <right_val>9.5173902809619904e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 2 1 -1.</_>
+                <_>
+                  1 17 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3475000159814954e-003</threshold>
+            <left_val>-3.9846318960189819e-001</left_val>
+            <right_val>1.0717230290174484e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 2 2 -1.</_>
+                <_>
+                  9 13 1 1 2.</_>
+                <_>
+                  8 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3271289644762874e-003</threshold>
+            <left_val>-7.6305247843265533e-002</left_val>
+            <right_val>1.5964789688587189e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 13 2 2 -1.</_>
+                <_>
+                  2 13 1 1 2.</_>
+                <_>
+                  3 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9857891388237476e-003</threshold>
+            <left_val>-1.0918959975242615e-001</left_val>
+            <right_val>3.6956569552421570e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 2 -1.</_>
+                <_>
+                  10 10 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7747710226103663e-003</threshold>
+            <left_val>-5.8550398796796799e-002</left_val>
+            <right_val>7.1181796491146088e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 3 2 -1.</_>
+                <_>
+                  1 10 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.9627179764211178e-003</threshold>
+            <left_val>3.6977839469909668e-001</left_val>
+            <right_val>-1.1677960306406021e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 7 3 3 -1.</_>
+                <_>
+                  9 8 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.0530123561620712e-003</threshold>
+            <left_val>-5.3131139278411865e-001</left_val>
+            <right_val>4.2773369699716568e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  7 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.0673801451921463e-002</threshold>
+            <left_val>6.5122097730636597e-001</left_val>
+            <right_val>-6.6222466528415680e-002</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 7 -1.</_>
+                <_>
+                  9 4 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.9803637713193893e-003</threshold>
+            <left_val>1.7810410261154175e-001</left_val>
+            <right_val>-4.8675179481506348e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 3 4 -1.</_>
+                <_>
+                  2 10 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0967300273478031e-002</threshold>
+            <left_val>6.3715361058712006e-002</left_val>
+            <right_val>-7.0216029882431030e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 7 -1.</_>
+                <_>
+                  9 4 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.1746408939361572e-003</threshold>
+            <left_val>-9.5948472619056702e-002</left_val>
+            <right_val>1.5818059444427490e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3564130067825317e+000</stage_threshold>
+      <parent>13</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 15 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 3 1 -1.</_>
+                <_>
+                  7 7 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4637179672718048e-002</threshold>
+            <left_val>4.5756229758262634e-001</left_val>
+            <right_val>-2.5793579220771790e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 1 3 -1.</_>
+                <_>
+                  9 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1372080189175904e-004</threshold>
+            <left_val>1.4856390655040741e-001</left_val>
+            <right_val>-1.3528409600257874e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 1 3 -1.</_>
+                <_>
+                  2 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.3527049496769905e-003</threshold>
+            <left_val>-1.8282939493656158e-001</left_val>
+            <right_val>5.0529718399047852e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 1 8 -1.</_>
+                <_>
+                  9 15 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4946528719738126e-004</threshold>
+            <left_val>-3.5463958978652954e-001</left_val>
+            <right_val>1.1956059932708740e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 12 2 -1.</_>
+                <_>
+                  0 4 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5882786661386490e-003</threshold>
+            <left_val>-3.6795818805694580e-001</left_val>
+            <right_val>1.9289310276508331e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 11 2 5 -1.</_>
+                <_>
+                  10 11 1 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.3795471787452698e-002</threshold>
+            <left_val>-9.2534601688385010e-001</left_val>
+            <right_val>-3.0407099984586239e-003</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 11 1 8 -1.</_>
+                <_>
+                  2 15 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2914909981191158e-002</threshold>
+            <left_val>2.0769760012626648e-001</left_val>
+            <right_val>-2.8073310852050781e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 6 7 -1.</_>
+                <_>
+                  6 12 3 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.5217018127441406e-002</threshold>
+            <left_val>9.1229602694511414e-002</left_val>
+            <right_val>-3.9509040117263794e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 2 -1.</_>
+                <_>
+                  0 0 2 1 2.</_>
+                <_>
+                  2 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5482950024306774e-002</threshold>
+            <left_val>5.5492401123046875e-001</left_val>
+            <right_val>-1.0178919881582260e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 6 7 -1.</_>
+                <_>
+                  6 12 3 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.0964470505714417e-002</threshold>
+            <left_val>-6.0590541362762451e-001</left_val>
+            <right_val>3.3235780894756317e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 6 7 -1.</_>
+                <_>
+                  3 12 3 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4792110025882721e-001</threshold>
+            <left_val>6.8140488862991333e-001</left_val>
+            <right_val>-9.2882059514522552e-002</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 2 1 8 -1.</_>
+                <_>
+                  6 4 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.2156299799680710e-002</threshold>
+            <left_val>-1.3000990450382233e-001</left_val>
+            <right_val>1.6143409907817841e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 8 1 -1.</_>
+                <_>
+                  6 4 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.5202730000019073e-003</threshold>
+            <left_val>1.8147900700569153e-001</left_val>
+            <right_val>-3.2928371429443359e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 3 -1.</_>
+                <_>
+                  8 11 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7749259248375893e-002</threshold>
+            <left_val>-6.7472197115421295e-002</left_val>
+            <right_val>2.4095970392227173e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 10 3 3 -1.</_>
+                <_>
+                  4 11 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4773460105061531e-002</threshold>
+            <left_val>-7.1976912021636963e-001</left_val>
+            <right_val>7.0244252681732178e-002</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 8 2 -1.</_>
+                <_>
+                  4 0 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.1384380757808685e-002</threshold>
+            <left_val>-6.6300392150878906e-001</left_val>
+            <right_val>6.1542339622974396e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 3 2 -1.</_>
+                <_>
+                  7 8 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1285319924354553e-002</threshold>
+            <left_val>-1.1147149652242661e-001</left_val>
+            <right_val>4.2070099711418152e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 4 6 12 -1.</_>
+                <_>
+                  3 8 6 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.3818488959223032e-004</threshold>
+            <left_val>1.3580459356307983e-001</left_val>
+            <right_val>-3.6389431357383728e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 3 3 -1.</_>
+                <_>
+                  0 8 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5372340828180313e-003</threshold>
+            <left_val>-6.2848389148712158e-001</left_val>
+            <right_val>7.5644947588443756e-002</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 11 4 6 -1.</_>
+                <_>
+                  8 13 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.8880869299173355e-002</threshold>
+            <left_val>-4.4123521447181702e-001</left_val>
+            <right_val>5.2693258039653301e-003</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 4 6 -1.</_>
+                <_>
+                  0 13 4 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7623539566993713e-002</threshold>
+            <left_val>6.0741778463125229e-002</left_val>
+            <right_val>-7.3273491859436035e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 17 8 2 -1.</_>
+                <_>
+                  7 17 4 1 2.</_>
+                <_>
+                  3 18 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.9864239990711212e-003</threshold>
+            <left_val>-9.5100089907646179e-002</left_val>
+            <right_val>1.3218070566654205e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 10 5 -1.</_>
+                <_>
+                  5 14 5 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5848229825496674e-001</threshold>
+            <left_val>-2.3477560281753540e-001</left_val>
+            <right_val>2.0766119658946991e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 11 3 1 -1.</_>
+                <_>
+                  9 11 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.2148280404508114e-003</threshold>
+            <left_val>1.3150349259376526e-001</left_val>
+            <right_val>-7.2531886398792267e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 11 3 1 -1.</_>
+                <_>
+                  2 11 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4197169113904238e-003</threshold>
+            <left_val>3.4369221329689026e-001</left_val>
+            <right_val>-1.3603129982948303e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 1 3 6 -1.</_>
+                <_>
+                  10 2 1 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3667210005223751e-002</threshold>
+            <left_val>-1.1352819949388504e-001</left_val>
+            <right_val>1.8905560672283173e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 18 -1.</_>
+                <_>
+                  0 9 12 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.4907150268554688e-001</threshold>
+            <left_val>-2.0564649999141693e-001</left_val>
+            <right_val>2.0814339816570282e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 6 1 2 -1.</_>
+                <_>
+                  8 6 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.3180799558758736e-002</threshold>
+            <left_val>-7.0410561561584473e-001</left_val>
+            <right_val>6.5354611724615097e-003</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  7 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4704890325665474e-002</threshold>
+            <left_val>4.3212160468101501e-001</left_val>
+            <right_val>-1.0485579818487167e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 1 3 6 -1.</_>
+                <_>
+                  10 2 1 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.5061739385128021e-002</threshold>
+            <left_val>-5.6936308741569519e-002</left_val>
+            <right_val>2.4053120613098145e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 1 6 3 -1.</_>
+                <_>
+                  2 2 6 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.8482209891080856e-002</threshold>
+            <left_val>-6.4425909519195557e-001</left_val>
+            <right_val>6.7065469920635223e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 2 3 -1.</_>
+                <_>
+                  8 12 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.4022173434495926e-003</threshold>
+            <left_val>-8.7327830493450165e-002</left_val>
+            <right_val>1.0236190259456635e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 3 2 -1.</_>
+                <_>
+                  4 12 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2662390246987343e-002</threshold>
+            <left_val>6.4649492502212524e-002</left_val>
+            <right_val>-6.6464841365814209e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 4 4 -1.</_>
+                <_>
+                  8 6 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8630980048328638e-004</threshold>
+            <left_val>8.8812537491321564e-002</left_val>
+            <right_val>-1.4801080524921417e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 4 4 -1.</_>
+                <_>
+                  0 6 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.3631217926740646e-003</threshold>
+            <left_val>-6.1257928609848022e-001</left_val>
+            <right_val>7.0822767913341522e-002</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 17 3 3 -1.</_>
+                <_>
+                  5 18 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.2741650938987732e-003</threshold>
+            <left_val>1.6412730515003204e-001</left_val>
+            <right_val>-1.3364849984645844e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 15 1 3 -1.</_>
+                <_>
+                  4 16 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.4096399322152138e-003</threshold>
+            <left_val>-1.2046200037002563e-001</left_val>
+            <right_val>3.2251781225204468e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 10 2 4 -1.</_>
+                <_>
+                  11 10 1 2 2.</_>
+                <_>
+                  10 12 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0664960611611605e-003</threshold>
+            <left_val>8.0544687807559967e-002</left_val>
+            <right_val>-3.9290331304073334e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 2 4 -1.</_>
+                <_>
+                  0 10 1 2 2.</_>
+                <_>
+                  1 12 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.1488898247480392e-003</threshold>
+            <left_val>3.5944211483001709e-001</left_val>
+            <right_val>-1.1370600014925003e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 4 3 6 -1.</_>
+                <_>
+                  10 4 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4608979690819979e-003</threshold>
+            <left_val>-1.4393359422683716e-001</left_val>
+            <right_val>1.0468409955501556e-001</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 3 6 -1.</_>
+                <_>
+                  1 4 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2510320171713829e-002</threshold>
+            <left_val>3.0024001002311707e-001</left_val>
+            <right_val>-1.3041430711746216e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 7 2 6 -1.</_>
+                <_>
+                  11 7 1 3 2.</_>
+                <_>
+                  10 10 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6470119357109070e-002</threshold>
+            <left_val>-3.4044870734214783e-001</left_val>
+            <right_val>2.2476559504866600e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 2 6 -1.</_>
+                <_>
+                  0 7 1 3 2.</_>
+                <_>
+                  1 10 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3765309937298298e-002</threshold>
+            <left_val>4.4677600264549255e-001</left_val>
+            <right_val>-9.7284018993377686e-002</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 8 2 3 -1.</_>
+                <_>
+                  10 9 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0946969996439293e-004</threshold>
+            <left_val>-2.0872430503368378e-001</left_val>
+            <right_val>1.5401780605316162e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 3 3 -1.</_>
+                <_>
+                  0 9 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.9605209864675999e-003</threshold>
+            <left_val>-8.2299548387527466e-001</left_val>
+            <right_val>4.8897851258516312e-002</right_val></_></_></trees>
+      <stage_threshold>-1.2748670578002930e+000</stage_threshold>
+      <parent>14</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 16 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 1 -1.</_>
+                <_>
+                  2 0 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.9184081144630909e-003</threshold>
+            <left_val>-3.2976099848747253e-001</left_val>
+            <right_val>3.1599700450897217e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 4 3 -1.</_>
+                <_>
+                  4 7 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.4240734577178955e-003</threshold>
+            <left_val>3.2350379228591919e-001</left_val>
+            <right_val>-2.4553489685058594e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 10 10 -1.</_>
+                <_>
+                  0 8 5 5 2.</_>
+                <_>
+                  5 13 5 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0760910212993622e-001</threshold>
+            <left_val>-2.7401238679885864e-001</left_val>
+            <right_val>2.4197450280189514e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 1 8 -1.</_>
+                <_>
+                  8 0 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.5002899803221226e-002</threshold>
+            <left_val>8.3533883094787598e-002</left_val>
+            <right_val>-2.5596448779106140e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 4 1 -1.</_>
+                <_>
+                  3 6 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.2144610993564129e-003</threshold>
+            <left_val>-2.2534610331058502e-001</left_val>
+            <right_val>2.2740550339221954e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 1 8 -1.</_>
+                <_>
+                  8 0 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.0699690133333206e-002</threshold>
+            <left_val>1.8549209833145142e-001</left_val>
+            <right_val>-1.9505530595779419e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  6 13 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.6538339704275131e-002</threshold>
+            <left_val>6.1330437660217285e-001</left_val>
+            <right_val>-8.7735809385776520e-002</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 19 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4412499964237213e-002</threshold>
+            <left_val>2.4093009531497955e-001</left_val>
+            <right_val>-2.7344560623168945e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 18 1 2 -1.</_>
+                <_>
+                  3 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4219420263543725e-003</threshold>
+            <left_val>-6.0177552700042725e-001</left_val>
+            <right_val>1.0058429837226868e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 10 2 6 -1.</_>
+                <_>
+                  10 10 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6331190243363380e-002</threshold>
+            <left_val>2.1288860589265823e-002</left_val>
+            <right_val>-5.0142019987106323e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 2 6 -1.</_>
+                <_>
+                  1 10 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4106729999184608e-002</threshold>
+            <left_val>-1.8390950560569763e-001</left_val>
+            <right_val>2.6597890257835388e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 1 8 -1.</_>
+                <_>
+                  8 0 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.9360690172761679e-004</threshold>
+            <left_val>3.0524199828505516e-002</left_val>
+            <right_val>-2.0498749613761902e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 4 2 -1.</_>
+                <_>
+                  4 2 2 1 2.</_>
+                <_>
+                  6 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.0101441815495491e-003</threshold>
+            <left_val>4.0488889813423157e-001</left_val>
+            <right_val>-1.1826159805059433e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 12 2 -1.</_>
+                <_>
+                  0 8 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.4736358821392059e-002</threshold>
+            <left_val>9.0163238346576691e-002</left_val>
+            <right_val>-4.8485979437828064e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 2 -1.</_>
+                <_>
+                  5 0 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.7224488593637943e-003</threshold>
+            <left_val>-5.4630178213119507e-001</left_val>
+            <right_val>7.3308691382408142e-002</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 3 3 -1.</_>
+                <_>
+                  7 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2748160399496555e-002</threshold>
+            <left_val>-6.7641848325729370e-001</left_val>
+            <right_val>3.2798580825328827e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 3 3 -1.</_>
+                <_>
+                  4 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.3234830051660538e-003</threshold>
+            <left_val>-6.3869500160217285e-001</left_val>
+            <right_val>5.4413169622421265e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 1 3 -1.</_>
+                <_>
+                  5 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7713790759444237e-002</threshold>
+            <left_val>-7.4989777803421021e-001</left_val>
+            <right_val>6.3041099347174168e-003</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 4 -1.</_>
+                <_>
+                  0 1 1 2 2.</_>
+                <_>
+                  1 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1022159829735756e-002</threshold>
+            <left_val>4.7562441229820251e-001</left_val>
+            <right_val>-8.7812356650829315e-002</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 4 -1.</_>
+                <_>
+                  11 1 1 2 2.</_>
+                <_>
+                  10 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.2062062099575996e-003</threshold>
+            <left_val>-5.1175302267074585e-001</left_val>
+            <right_val>3.8222119212150574e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 4 -1.</_>
+                <_>
+                  0 1 1 2 2.</_>
+                <_>
+                  1 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.8669954091310501e-003</threshold>
+            <left_val>-1.0822050273418427e-001</left_val>
+            <right_val>4.3007129430770874e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 8 3 3 -1.</_>
+                <_>
+                  9 9 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4753219671547413e-002</threshold>
+            <left_val>3.0923029407858849e-002</left_val>
+            <right_val>-5.8399969339370728e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 2 2 -1.</_>
+                <_>
+                  6 16 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.7396129965782166e-003</threshold>
+            <left_val>-5.5709302425384521e-001</left_val>
+            <right_val>6.5057590603828430e-002</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 2 1 -1.</_>
+                <_>
+                  6 8 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8765570130199194e-003</threshold>
+            <left_val>2.0753450691699982e-001</left_val>
+            <right_val>-1.0404630005359650e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 1 -1.</_>
+                <_>
+                  7 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.1403261497616768e-003</threshold>
+            <left_val>-8.8196322321891785e-002</left_val>
+            <right_val>5.0393581390380859e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 2 3 -1.</_>
+                <_>
+                  5 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.2455530278384686e-003</threshold>
+            <left_val>4.5692878961563110e-001</left_val>
+            <right_val>-8.8871538639068604e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 3 3 -1.</_>
+                <_>
+                  1 7 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.5213078632950783e-003</threshold>
+            <left_val>-7.3358172178268433e-001</left_val>
+            <right_val>6.1022911220788956e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 1 1 8 -1.</_>
+                <_>
+                  6 3 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.4276527166366577e-002</threshold>
+            <left_val>-5.1953801885247231e-003</left_val>
+            <right_val>-7.2847050428390503e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 8 1 -1.</_>
+                <_>
+                  6 3 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2186209671199322e-002</threshold>
+            <left_val>8.0246433615684509e-002</left_val>
+            <right_val>-4.9406829476356506e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 3 4 -1.</_>
+                <_>
+                  7 14 3 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.2070740610361099e-002</threshold>
+            <left_val>5.3785991668701172e-001</left_val>
+            <right_val>-2.6184149086475372e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 1 8 -1.</_>
+                <_>
+                  5 7 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8056540284305811e-003</threshold>
+            <left_val>1.2499610334634781e-001</left_val>
+            <right_val>-3.1014269590377808e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 3 3 -1.</_>
+                <_>
+                  8 12 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.5525551065802574e-003</threshold>
+            <left_val>-1.4355179667472839e-001</left_val>
+            <right_val>9.3508958816528320e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 13 4 3 -1.</_>
+                <_>
+                  5 14 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.1722750738263130e-002</threshold>
+            <left_val>5.4289009422063828e-002</left_val>
+            <right_val>-6.9004470109939575e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 4 -1.</_>
+                <_>
+                  9 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5696860849857330e-002</threshold>
+            <left_val>-6.2646992504596710e-002</left_val>
+            <right_val>5.2328252792358398e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  7 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1486239731311798e-002</threshold>
+            <left_val>-1.7067709565162659e-001</left_val>
+            <right_val>2.5379261374473572e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 4 -1.</_>
+                <_>
+                  9 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.0110350847244263e-002</threshold>
+            <left_val>2.1845239400863647e-001</left_val>
+            <right_val>-3.2540921121835709e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 4 3 -1.</_>
+                <_>
+                  3 5 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.3832129314541817e-002</threshold>
+            <left_val>-7.2852367162704468e-001</left_val>
+            <right_val>5.6103359907865524e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 4 2 -1.</_>
+                <_>
+                  6 9 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8152900040149689e-002</threshold>
+            <left_val>7.9692779108881950e-003</left_val>
+            <right_val>-5.0108677148818970e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 8 5 2 -1.</_>
+                <_>
+                  2 9 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.9337781965732574e-003</threshold>
+            <left_val>-5.4861277341842651e-001</left_val>
+            <right_val>7.4599482119083405e-002</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 4 -1.</_>
+                <_>
+                  6 15 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8721539303660393e-002</threshold>
+            <left_val>-5.0967568159103394e-001</left_val>
+            <right_val>1.3899230398237705e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 1 -1.</_>
+                <_>
+                  6 0 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.0404408723115921e-003</threshold>
+            <left_val>8.0196216702461243e-002</left_val>
+            <right_val>-4.5811289548873901e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 1 1 3 -1.</_>
+                <_>
+                  10 2 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7407380044460297e-002</threshold>
+            <left_val>-6.7178148031234741e-001</left_val>
+            <right_val>7.8524583950638771e-003</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 1 3 1 -1.</_>
+                <_>
+                  2 2 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.8755920231342316e-002</threshold>
+            <left_val>-7.0715762674808502e-002</left_val>
+            <right_val>5.2900022268295288e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 7 -1.</_>
+                <_>
+                  9 4 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5297430157661438e-003</threshold>
+            <left_val>-5.4971348494291306e-002</left_val>
+            <right_val>1.2586890161037445e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 4 3 7 -1.</_>
+                <_>
+                  2 4 1 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.7714699506759644e-002</threshold>
+            <left_val>-9.4051122665405273e-002</left_val>
+            <right_val>3.9269289374351501e-001</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 2 -1.</_>
+                <_>
+                  10 0 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.9136169925332069e-002</threshold>
+            <left_val>-6.1292767524719238e-001</left_val>
+            <right_val>4.3676119297742844e-002</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 3 4 -1.</_>
+                <_>
+                  2 6 1 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1729629710316658e-002</threshold>
+            <left_val>4.0649351477622986e-001</left_val>
+            <right_val>-1.0054980218410492e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 3 -1.</_>
+                <_>
+                  10 0 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.6842709630727768e-003</threshold>
+            <left_val>6.1806179583072662e-002</left_val>
+            <right_val>-2.6040008664131165e-001</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 3 2 -1.</_>
+                <_>
+                  2 0 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3504150323569775e-002</threshold>
+            <left_val>6.3247829675674438e-002</left_val>
+            <right_val>-6.1916601657867432e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 5 1 3 -1.</_>
+                <_>
+                  10 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8922952264547348e-003</threshold>
+            <left_val>-7.3288178443908691e-001</left_val>
+            <right_val>4.1912440210580826e-002</right_val></_></_></trees>
+      <stage_threshold>-1.2878630161285400e+000</stage_threshold>
+      <parent>15</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 17 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 3 -1.</_>
+                <_>
+                  5 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0124780237674713e-002</threshold>
+            <left_val>-2.2478839755058289e-001</left_val>
+            <right_val>4.9562188982963562e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 6 9 -1.</_>
+                <_>
+                  6 4 6 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0572949945926666e-001</threshold>
+            <left_val>2.6126179844141006e-002</left_val>
+            <right_val>-7.9092139005661011e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 2 9 -1.</_>
+                <_>
+                  4 4 2 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7348840832710266e-002</threshold>
+            <left_val>-3.8796889781951904e-001</left_val>
+            <right_val>2.0708920061588287e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 8 18 -1.</_>
+                <_>
+                  8 1 4 9 2.</_>
+                <_>
+                  4 10 4 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.5478509068489075e-001</threshold>
+            <left_val>-5.7850080728530884e-001</left_val>
+            <right_val>1.2234980240464211e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 4 6 -1.</_>
+                <_>
+                  4 17 4 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8602819889783859e-002</threshold>
+            <left_val>1.7568160593509674e-001</left_val>
+            <right_val>-3.7877011299133301e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 4 -1.</_>
+                <_>
+                  11 1 1 2 2.</_>
+                <_>
+                  10 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.1557251289486885e-003</threshold>
+            <left_val>5.8734539896249771e-002</left_val>
+            <right_val>-5.3387188911437988e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 4 -1.</_>
+                <_>
+                  0 1 1 2 2.</_>
+                <_>
+                  1 3 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.7997328005731106e-003</threshold>
+            <left_val>4.2286089062690735e-001</left_val>
+            <right_val>-1.5031290054321289e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 4 17 -1.</_>
+                <_>
+                  5 0 2 17 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.0167991816997528e-002</threshold>
+            <left_val>-4.7068008780479431e-001</left_val>
+            <right_val>1.9146749749779701e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 4 17 -1.</_>
+                <_>
+                  5 0 2 17 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0075060427188873e-002</threshold>
+            <left_val>1.5215730667114258e-001</left_val>
+            <right_val>-3.0286580324172974e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 2 8 -1.</_>
+                <_>
+                  8 9 2 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.5905030071735382e-001</threshold>
+            <left_val>4.8262810707092285e-001</left_val>
+            <right_val>-5.5345159024000168e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 12 12 -1.</_>
+                <_>
+                  6 8 6 12 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0053060203790665e-001</threshold>
+            <left_val>-3.1768739223480225e-001</left_val>
+            <right_val>1.8654659390449524e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 12 2 2 -1.</_>
+                <_>
+                  8 12 1 1 2.</_>
+                <_>
+                  7 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9778450261801481e-003</threshold>
+            <left_val>-4.3355960398912430e-002</left_val>
+            <right_val>3.0445128679275513e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 4 3 -1.</_>
+                <_>
+                  0 10 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.8455971777439117e-003</threshold>
+            <left_val>-6.5422862768173218e-001</left_val>
+            <right_val>5.7101141661405563e-002</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 2 3 -1.</_>
+                <_>
+                  5 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.3462900891900063e-002</threshold>
+            <left_val>-7.4357628822326660e-001</left_val>
+            <right_val>1.1618070304393768e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 2 -1.</_>
+                <_>
+                  4 0 2 1 2.</_>
+                <_>
+                  6 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.4667708724737167e-003</threshold>
+            <left_val>-1.1318150162696838e-001</left_val>
+            <right_val>3.4910741448402405e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 12 -1.</_>
+                <_>
+                  11 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9225839301943779e-002</threshold>
+            <left_val>-3.8572481274604797e-001</left_val>
+            <right_val>2.5479009747505188e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 2 1 18 -1.</_>
+                <_>
+                  1 11 1 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1265130341053009e-001</threshold>
+            <left_val>-9.8677836358547211e-002</left_val>
+            <right_val>7.0809727907180786e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 4 5 -1.</_>
+                <_>
+                  6 5 2 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0059010237455368e-001</threshold>
+            <left_val>3.9431888610124588e-002</left_val>
+            <right_val>-2.0872689783573151e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 8 2 -1.</_>
+                <_>
+                  5 7 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4622969552874565e-002</threshold>
+            <left_val>1.0739020258188248e-001</left_val>
+            <right_val>-4.4337108731269836e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 2 -1.</_>
+                <_>
+                  10 0 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.9183081611990929e-003</threshold>
+            <left_val>2.2479789331555367e-002</left_val>
+            <right_val>-4.7095221281051636e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 2 2 -1.</_>
+                <_>
+                  2 0 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1137289926409721e-002</threshold>
+            <left_val>-5.3821432590484619e-001</left_val>
+            <right_val>7.1250103414058685e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 2 8 -1.</_>
+                <_>
+                  8 9 2 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.0612619817256927e-001</threshold>
+            <left_val>2.5029089301824570e-003</left_val>
+            <right_val>-5.5134499073028564e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 8 2 -1.</_>
+                <_>
+                  4 9 4 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9606389105319977e-002</threshold>
+            <left_val>6.8830899894237518e-002</left_val>
+            <right_val>-5.8748298883438110e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 2 3 -1.</_>
+                <_>
+                  8 12 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4237780123949051e-002</threshold>
+            <left_val>-1.0993599891662598e-001</left_val>
+            <right_val>2.2019009292125702e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 3 2 -1.</_>
+                <_>
+                  4 12 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1579900048673153e-002</threshold>
+            <left_val>-6.0401040315628052e-001</left_val>
+            <right_val>6.1112940311431885e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 2 2 -1.</_>
+                <_>
+                  9 12 1 1 2.</_>
+                <_>
+                  8 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.7201389893889427e-003</threshold>
+            <left_val>-8.6882777512073517e-002</left_val>
+            <right_val>2.1160760521888733e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 2 2 -1.</_>
+                <_>
+                  2 12 1 1 2.</_>
+                <_>
+                  3 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.3311892077326775e-003</threshold>
+            <left_val>-8.5722766816616058e-002</left_val>
+            <right_val>4.3251448869705200e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 2 2 -1.</_>
+                <_>
+                  8 13 1 1 2.</_>
+                <_>
+                  7 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4856910565868020e-003</threshold>
+            <left_val>-3.5430859774351120e-002</left_val>
+            <right_val>1.4321969449520111e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 13 2 2 -1.</_>
+                <_>
+                  3 13 1 1 2.</_>
+                <_>
+                  4 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4972909595817327e-003</threshold>
+            <left_val>4.2610010504722595e-001</left_val>
+            <right_val>-1.0974500328302383e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 3 -1.</_>
+                <_>
+                  9 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3857520185410976e-002</threshold>
+            <left_val>2.1762149408459663e-002</left_val>
+            <right_val>-4.7706019878387451e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 7 3 -1.</_>
+                <_>
+                  2 3 7 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.3594869300723076e-002</threshold>
+            <left_val>-4.6244761347770691e-001</left_val>
+            <right_val>7.9718932509422302e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 18 2 2 -1.</_>
+                <_>
+                  10 19 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.0481400899589062e-003</threshold>
+            <left_val>1.7503540217876434e-001</left_val>
+            <right_val>-2.9865878820419312e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 2 2 -1.</_>
+                <_>
+                  0 19 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3127359561622143e-003</threshold>
+            <left_val>-5.5913221836090088e-001</left_val>
+            <right_val>7.1896396577358246e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 2 2 1 -1.</_>
+                <_>
+                  10 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3319691903889179e-003</threshold>
+            <left_val>-8.0651438236236572e-001</left_val>
+            <right_val>1.5199059620499611e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 2 1 -1.</_>
+                <_>
+                  1 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.6742340307682753e-003</threshold>
+            <left_val>4.2407768964767456e-001</left_val>
+            <right_val>-9.2443756759166718e-002</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 3 3 6 -1.</_>
+                <_>
+                  10 3 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5564959272742271e-002</threshold>
+            <left_val>2.9059829190373421e-002</left_val>
+            <right_val>-4.8274171352386475e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 3 6 -1.</_>
+                <_>
+                  1 3 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.8129860758781433e-002</threshold>
+            <left_val>-8.0184653401374817e-002</left_val>
+            <right_val>5.2279758453369141e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 3 3 -1.</_>
+                <_>
+                  9 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8039072579704225e-005</threshold>
+            <left_val>-7.4344098567962646e-002</left_val>
+            <right_val>9.4045989215373993e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 3 3 -1.</_>
+                <_>
+                  0 11 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.6100970357656479e-003</threshold>
+            <left_val>-5.1046329736709595e-001</left_val>
+            <right_val>7.0259310305118561e-002</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 2 2 -1.</_>
+                <_>
+                  10 11 1 1 2.</_>
+                <_>
+                  9 12 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4607360828667879e-003</threshold>
+            <left_val>-7.3687382042407990e-002</left_val>
+            <right_val>1.7185910046100616e-001</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 11 2 2 -1.</_>
+                <_>
+                  1 11 1 1 2.</_>
+                <_>
+                  2 12 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8461809959262609e-003</threshold>
+            <left_val>3.2514411211013794e-001</left_val>
+            <right_val>-1.2517750263214111e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 1 3 -1.</_>
+                <_>
+                  8 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.6498539955355227e-004</threshold>
+            <left_val>-1.0129640251398087e-001</left_val>
+            <right_val>5.4491110146045685e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 4 2 -1.</_>
+                <_>
+                  6 12 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3974959962069988e-002</threshold>
+            <left_val>1.0203190147876740e-001</left_val>
+            <right_val>-3.9044409990310669e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 1 3 -1.</_>
+                <_>
+                  8 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.3575310371816158e-003</threshold>
+            <left_val>-6.4226530492305756e-002</left_val>
+            <right_val>5.4202359169721603e-002</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 1 -1.</_>
+                <_>
+                  4 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.3201949708163738e-003</threshold>
+            <left_val>5.9934031218290329e-002</left_val>
+            <right_val>-6.0588258504867554e-001</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 12 2 2 -1.</_>
+                <_>
+                  8 12 1 1 2.</_>
+                <_>
+                  7 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2428000336512923e-003</threshold>
+            <left_val>1.1665280163288116e-001</left_val>
+            <right_val>-7.2288237512111664e-002</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 2 2 -1.</_>
+                <_>
+                  3 12 1 1 2.</_>
+                <_>
+                  4 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8044740427285433e-003</threshold>
+            <left_val>3.4149900078773499e-001</left_val>
+            <right_val>-9.8468907177448273e-002</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 6 1 3 -1.</_>
+                <_>
+                  10 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8408531583845615e-003</threshold>
+            <left_val>-5.3094178438186646e-001</left_val>
+            <right_val>3.1446449458599091e-002</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 2 -1.</_>
+                <_>
+                  0 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.5861881226301193e-003</threshold>
+            <left_val>-1.6896879673004150e-001</left_val>
+            <right_val>1.9897870719432831e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 16 1 4 -1.</_>
+                <_>
+                  11 17 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3223010115325451e-002</threshold>
+            <left_val>2.6502050459384918e-002</left_val>
+            <right_val>-6.1782538890838623e-001</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 1 4 -1.</_>
+                <_>
+                  0 17 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3310019858181477e-003</threshold>
+            <left_val>-3.7018761038780212e-001</left_val>
+            <right_val>8.9922286570072174e-002</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 16 1 3 -1.</_>
+                <_>
+                  11 17 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4923400012776256e-003</threshold>
+            <left_val>-3.2771658897399902e-001</left_val>
+            <right_val>6.3753470778465271e-002</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 1 3 -1.</_>
+                <_>
+                  0 17 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3128539323806763e-003</threshold>
+            <left_val>5.8098889887332916e-002</left_val>
+            <right_val>-5.7217907905578613e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 2 3 -1.</_>
+                <_>
+                  5 9 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.9470911026000977e-002</threshold>
+            <left_val>-5.9376251697540283e-001</left_val>
+            <right_val>2.4938920978456736e-003</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 3 2 -1.</_>
+                <_>
+                  7 9 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1061299592256546e-002</threshold>
+            <left_val>-9.7631797194480896e-002</left_val>
+            <right_val>3.4335118532180786e-001</right_val></_></_>
+        <_>
+          <!-- tree 55 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 14 2 2 -1.</_>
+                <_>
+                  9 14 1 1 2.</_>
+                <_>
+                  8 15 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7588209593668580e-003</threshold>
+            <left_val>-3.3723760396242142e-002</left_val>
+            <right_val>1.8667000532150269e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3936669826507568e+000</stage_threshold>
+      <parent>16</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 18 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 5 3 -1.</_>
+                <_>
+                  3 7 5 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3175318278372288e-003</threshold>
+            <left_val>2.6701891422271729e-001</left_val>
+            <right_val>-3.5374870896339417e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 1 3 -1.</_>
+                <_>
+                  9 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3007350265979767e-002</threshold>
+            <left_val>8.7024876847863197e-003</left_val>
+            <right_val>-7.5992470979690552e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 1 3 -1.</_>
+                <_>
+                  2 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.8762829974293709e-003</threshold>
+            <left_val>-2.0284099876880646e-001</left_val>
+            <right_val>4.1433459520339966e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 4 11 -1.</_>
+                <_>
+                  8 5 2 11 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0705440305173397e-002</threshold>
+            <left_val>2.0144259929656982e-001</left_val>
+            <right_val>-2.9292601346969604e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 15 4 2 -1.</_>
+                <_>
+                  1 15 2 1 2.</_>
+                <_>
+                  3 16 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4717481359839439e-003</threshold>
+            <left_val>2.9785239696502686e-001</left_val>
+            <right_val>-2.1515479683876038e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 3 3 10 -1.</_>
+                <_>
+                  8 3 1 10 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0971710085868835e-001</threshold>
+            <left_val>-9.0043932199478149e-001</left_val>
+            <right_val>4.1688669472932816e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 3 3 10 -1.</_>
+                <_>
+                  3 3 1 10 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4193130433559418e-002</threshold>
+            <left_val>-1.7109879851341248e-001</left_val>
+            <right_val>3.1211599707603455e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 3 2 -1.</_>
+                <_>
+                  9 14 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4174679070711136e-002</threshold>
+            <left_val>2.8407519683241844e-002</left_val>
+            <right_val>-5.3422790765762329e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 13 2 3 -1.</_>
+                <_>
+                  3 14 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.1222220733761787e-002</threshold>
+            <left_val>-1.1979670077562332e-001</left_val>
+            <right_val>4.4222798943519592e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 12 6 -1.</_>
+                <_>
+                  0 4 12 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6180870831012726e-002</threshold>
+            <left_val>-5.3708368539810181e-001</left_val>
+            <right_val>8.5554197430610657e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 2 4 -1.</_>
+                <_>
+                  1 7 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.6309800818562508e-003</threshold>
+            <left_val>-6.3450610637664795e-001</left_val>
+            <right_val>7.8415229916572571e-002</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 3 -1.</_>
+                <_>
+                  10 5 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.1208908446133137e-003</threshold>
+            <left_val>-5.8184450864791870e-001</left_val>
+            <right_val>5.6262150406837463e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 2 -1.</_>
+                <_>
+                  3 0 3 1 2.</_>
+                <_>
+                  6 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4345550686120987e-002</threshold>
+            <left_val>-8.2362763583660126e-002</left_val>
+            <right_val>5.2085632085800171e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 3 3 -1.</_>
+                <_>
+                  8 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0590479709208012e-002</threshold>
+            <left_val>-5.8450412750244141e-001</left_val>
+            <right_val>3.7550948560237885e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 3 3 -1.</_>
+                <_>
+                  3 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.4336008876562119e-003</threshold>
+            <left_val>-7.2815698385238647e-001</left_val>
+            <right_val>4.3281048536300659e-002</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  5 5 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5999199599027634e-002</threshold>
+            <left_val>2.3103030398488045e-002</left_val>
+            <right_val>-4.7821858525276184e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  7 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5073610246181488e-002</threshold>
+            <left_val>-1.0790230333805084e-001</left_val>
+            <right_val>3.5499471426010132e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 8 16 -1.</_>
+                <_>
+                  8 2 4 8 2.</_>
+                <_>
+                  4 10 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9070028662681580e-001</threshold>
+            <left_val>6.3703400082886219e-003</left_val>
+            <right_val>-8.6412417888641357e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 8 16 -1.</_>
+                <_>
+                  0 2 4 8 2.</_>
+                <_>
+                  4 10 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7590269446372986e-001</threshold>
+            <left_val>-2.5589939951896667e-001</left_val>
+            <right_val>1.6987270116806030e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  6 13 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.2584410160779953e-002</threshold>
+            <left_val>-6.2721168994903564e-001</left_val>
+            <right_val>1.8344789743423462e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  6 13 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.1382450610399246e-002</threshold>
+            <left_val>5.4475349187850952e-001</left_val>
+            <right_val>-1.0436189919710159e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 9 2 7 -1.</_>
+                <_>
+                  10 9 1 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.6197769269347191e-003</threshold>
+            <left_val>1.4069239795207977e-001</left_val>
+            <right_val>-4.0490731596946716e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 18 1 2 -1.</_>
+                <_>
+                  3 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0080020185559988e-003</threshold>
+            <left_val>9.3814283609390259e-002</left_val>
+            <right_val>-4.5978298783302307e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 18 8 2 -1.</_>
+                <_>
+                  6 18 4 1 2.</_>
+                <_>
+                  2 19 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1478760279715061e-002</threshold>
+            <left_val>-2.3005740344524384e-001</left_val>
+            <right_val>1.8548269569873810e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 4 3 -1.</_>
+                <_>
+                  4 6 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.1993194073438644e-003</threshold>
+            <left_val>4.3196168541908264e-001</left_val>
+            <right_val>-8.4990806877613068e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 4 2 -1.</_>
+                <_>
+                  4 5 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.2873731106519699e-004</threshold>
+            <left_val>-3.2470309734344482e-001</left_val>
+            <right_val>1.2502589821815491e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 9 -1.</_>
+                <_>
+                  1 9 1 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6286820173263550e-002</threshold>
+            <left_val>-1.6808439791202545e-001</left_val>
+            <right_val>2.0208799839019775e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 13 2 2 -1.</_>
+                <_>
+                  9 13 1 1 2.</_>
+                <_>
+                  8 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.8326708646491170e-004</threshold>
+            <left_val>1.3341540098190308e-001</left_val>
+            <right_val>-8.0567203462123871e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 13 2 2 -1.</_>
+                <_>
+                  2 13 1 1 2.</_>
+                <_>
+                  3 14 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.2098519839346409e-003</threshold>
+            <left_val>3.2481029629707336e-001</left_val>
+            <right_val>-1.1913210153579712e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 12 -1.</_>
+                <_>
+                  11 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.3911340869963169e-003</threshold>
+            <left_val>-6.4360022544860840e-001</left_val>
+            <right_val>9.3070819973945618e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 8 4 -1.</_>
+                <_>
+                  6 7 4 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.1501209586858749e-002</threshold>
+            <left_val>1.2166000157594681e-001</left_val>
+            <right_val>-2.8132438659667969e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 3 3 -1.</_>
+                <_>
+                  7 11 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3594830408692360e-002</threshold>
+            <left_val>-7.4954092502593994e-002</left_val>
+            <right_val>1.1320699751377106e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 3 2 -1.</_>
+                <_>
+                  5 0 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.9626200236380100e-003</threshold>
+            <left_val>-6.0876357555389404e-001</left_val>
+            <right_val>5.5802300572395325e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 11 3 3 -1.</_>
+                <_>
+                  9 12 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.1367057971656322e-003</threshold>
+            <left_val>1.3753290474414825e-001</left_val>
+            <right_val>-5.4944049566984177e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 14 2 2 -1.</_>
+                <_>
+                  3 14 1 1 2.</_>
+                <_>
+                  4 15 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7937159650027752e-003</threshold>
+            <left_val>-9.7331270575523376e-002</left_val>
+            <right_val>3.5290411114692688e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 7 -1.</_>
+                <_>
+                  0 13 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2037001252174377e-001</threshold>
+            <left_val>-6.0830309987068176e-002</left_val>
+            <right_val>6.2353998422622681e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 1 -1.</_>
+                <_>
+                  1 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3953109737485647e-003</threshold>
+            <left_val>-4.5005550980567932e-001</left_val>
+            <right_val>8.5933342576026917e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_>
+                <_>
+                  10 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.1760727809742093e-004</threshold>
+            <left_val>-2.7361738681793213e-001</left_val>
+            <right_val>4.9933131784200668e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 2 -1.</_>
+                <_>
+                  0 1 1 1 2.</_>
+                <_>
+                  1 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6983609423041344e-003</threshold>
+            <left_val>-9.6326000988483429e-002</left_val>
+            <right_val>4.4493889808654785e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_>
+                <_>
+                  10 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8104390474036336e-003</threshold>
+            <left_val>5.8886051177978516e-002</left_val>
+            <right_val>-2.8511041402816772e-001</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 2 -1.</_>
+                <_>
+                  0 1 1 1 2.</_>
+                <_>
+                  1 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.2683739922940731e-003</threshold>
+            <left_val>5.0250577926635742e-001</left_val>
+            <right_val>-1.0216759890317917e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 5 1 3 -1.</_>
+                <_>
+                  10 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.4583848901093006e-003</threshold>
+            <left_val>5.8127861469984055e-002</left_val>
+            <right_val>-5.9851872920989990e-001</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 5 1 3 -1.</_>
+                <_>
+                  1 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.5791560076177120e-003</threshold>
+            <left_val>-7.3496657609939575e-001</left_val>
+            <right_val>4.1422609239816666e-002</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 2 3 -1.</_>
+                <_>
+                  6 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.1315352320671082e-003</threshold>
+            <left_val>-9.3608200550079346e-002</left_val>
+            <right_val>1.7093980312347412e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 8 1 -1.</_>
+                <_>
+                  4 2 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.2571019381284714e-002</threshold>
+            <left_val>4.8374500870704651e-001</left_val>
+            <right_val>-7.8032270073890686e-002</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 4 3 -1.</_>
+                <_>
+                  8 9 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4648390002548695e-002</threshold>
+            <left_val>-4.8706358671188354e-001</left_val>
+            <right_val>2.5201629847288132e-002</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 4 3 -1.</_>
+                <_>
+                  0 9 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.3548959121108055e-003</threshold>
+            <left_val>3.9141140878200531e-002</left_val>
+            <right_val>-8.5132300853729248e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.7046807855367661e-003</threshold>
+            <left_val>2.7295690774917603e-001</left_val>
+            <right_val>-1.0840819776058197e-001</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 3 9 -1.</_>
+                <_>
+                  5 12 1 3 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.4468376338481903e-002</threshold>
+            <left_val>-8.0510532855987549e-001</left_val>
+            <right_val>4.7053340822458267e-002</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 9 3 2 -1.</_>
+                <_>
+                  8 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.9486463218927383e-003</threshold>
+            <left_val>3.0840569734573364e-001</left_val>
+            <right_val>-1.3387249410152435e-001</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 3 2 -1.</_>
+                <_>
+                  3 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9265598170459270e-003</threshold>
+            <left_val>3.6305388808250427e-001</left_val>
+            <right_val>-1.0540190339088440e-001</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 6 3 1 -1.</_>
+                <_>
+                  10 7 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.6044888198375702e-002</threshold>
+            <left_val>5.8140981197357178e-001</left_val>
+            <right_val>-2.9684588662348688e-004</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 1 3 -1.</_>
+                <_>
+                  2 7 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.6920147985219955e-003</threshold>
+            <left_val>3.3190870285034180e-001</left_val>
+            <right_val>-1.0925249755382538e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3580759763717651e+000</stage_threshold>
+      <parent>17</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 19 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 4 2 -1.</_>
+                <_>
+                  3 2 2 1 2.</_>
+                <_>
+                  5 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.9766711890697479e-003</threshold>
+            <left_val>3.7934410572052002e-001</left_val>
+            <right_val>-2.4959290027618408e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 4 3 -1.</_>
+                <_>
+                  5 4 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.4589890390634537e-002</threshold>
+            <left_val>-4.4946050643920898e-001</left_val>
+            <right_val>3.9635330438613892e-002</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 4 -1.</_>
+                <_>
+                  7 4 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9461639225482941e-002</threshold>
+            <left_val>-2.6357260346412659e-001</left_val>
+            <right_val>2.7247101068496704e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 16 -1.</_>
+                <_>
+                  8 0 2 16 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2663760483264923e-002</threshold>
+            <left_val>2.9581360518932343e-002</left_val>
+            <right_val>-3.4751391410827637e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 4 -1.</_>
+                <_>
+                  3 13 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.8530770242214203e-002</threshold>
+            <left_val>-3.0708679556846619e-001</left_val>
+            <right_val>2.0082889497280121e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 2 -1.</_>
+                <_>
+                  9 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.9736598953604698e-003</threshold>
+            <left_val>-5.4576981067657471e-001</left_val>
+            <right_val>2.3220159113407135e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 2 3 -1.</_>
+                <_>
+                  2 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.7464492060244083e-003</threshold>
+            <left_val>-1.4597670733928680e-001</left_val>
+            <right_val>3.5159158706665039e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 1 -1.</_>
+                <_>
+                  3 0 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.0320582017302513e-004</threshold>
+            <left_val>-3.5477969050407410e-001</left_val>
+            <right_val>1.4947199821472168e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 2 3 -1.</_>
+                <_>
+                  3 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3183569535613060e-002</threshold>
+            <left_val>4.9795240163803101e-001</left_val>
+            <right_val>-9.5576412975788116e-002</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 4 3 3 -1.</_>
+                <_>
+                  9 5 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1360269971191883e-002</threshold>
+            <left_val>4.4859439134597778e-002</left_val>
+            <right_val>-7.7702391147613525e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 3 3 -1.</_>
+                <_>
+                  0 5 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.3752749226987362e-003</threshold>
+            <left_val>-6.0436600446701050e-001</left_val>
+            <right_val>6.3452452421188354e-002</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 11 2 2 -1.</_>
+                <_>
+                  9 11 1 1 2.</_>
+                <_>
+                  8 12 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6277059223502874e-003</threshold>
+            <left_val>-5.9781100600957870e-002</left_val>
+            <right_val>1.6431820392608643e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 11 2 2 -1.</_>
+                <_>
+                  2 11 1 1 2.</_>
+                <_>
+                  3 12 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9063310464844108e-003</threshold>
+            <left_val>3.4500768780708313e-001</left_val>
+            <right_val>-1.1078260093927383e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 10 1 8 -1.</_>
+                <_>
+                  7 12 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.5438909679651260e-002</threshold>
+            <left_val>5.3140318393707275e-001</left_val>
+            <right_val>-3.9117269217967987e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 3 3 8 -1.</_>
+                <_>
+                  2 3 1 8 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.2990850731730461e-002</threshold>
+            <left_val>-1.1105979979038239e-001</left_val>
+            <right_val>3.4139779210090637e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 2 4 -1.</_>
+                <_>
+                  8 10 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3013869300484657e-002</threshold>
+            <left_val>1.9403599202632904e-002</left_val>
+            <right_val>-3.0652850866317749e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 15 3 4 -1.</_>
+                <_>
+                  2 16 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.2346909865736961e-003</threshold>
+            <left_val>1.8446859717369080e-001</left_val>
+            <right_val>-2.1846550703048706e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 4 3 6 -1.</_>
+                <_>
+                  9 4 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9735300447791815e-003</threshold>
+            <left_val>-6.4886763691902161e-002</left_val>
+            <right_val>6.2509037554264069e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 4 3 6 -1.</_>
+                <_>
+                  2 4 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0755480267107487e-002</threshold>
+            <left_val>3.5955241322517395e-001</left_val>
+            <right_val>-1.1030949652194977e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 2 3 -1.</_>
+                <_>
+                  7 13 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.6936439797282219e-002</threshold>
+            <left_val>-7.0569419860839844e-001</left_val>
+            <right_val>1.5028079971671104e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 10 8 1 -1.</_>
+                <_>
+                  5 12 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.8886420652270317e-002</threshold>
+            <left_val>5.0576541572809219e-002</left_val>
+            <right_val>-7.2815430164337158e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 15 1 3 -1.</_>
+                <_>
+                  7 16 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.7200351729989052e-003</threshold>
+            <left_val>-1.0274200141429901e-001</left_val>
+            <right_val>8.0553196370601654e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 6 3 -1.</_>
+                <_>
+                  0 17 6 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7981380224227905e-002</threshold>
+            <left_val>-7.0609301328659058e-001</left_val>
+            <right_val>5.8095961809158325e-002</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 2 2 -1.</_>
+                <_>
+                  9 12 1 1 2.</_>
+                <_>
+                  8 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6353320097550750e-003</threshold>
+            <left_val>-9.0820826590061188e-002</left_val>
+            <right_val>1.2195230275392532e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 2 2 -1.</_>
+                <_>
+                  2 12 1 1 2.</_>
+                <_>
+                  3 13 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8810540204867721e-003</threshold>
+            <left_val>3.1368181109428406e-001</left_val>
+            <right_val>-1.1835079640150070e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 1 3 -1.</_>
+                <_>
+                  8 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6305189579725266e-002</threshold>
+            <left_val>-3.4470620751380920e-001</left_val>
+            <right_val>1.0644529946148396e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 2 2 -1.</_>
+                <_>
+                  3 11 1 1 2.</_>
+                <_>
+                  4 12 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6981370281428099e-003</threshold>
+            <left_val>3.6481419205665588e-001</left_val>
+            <right_val>-1.0638120025396347e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 15 1 3 -1.</_>
+                <_>
+                  7 16 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.1174369379878044e-002</threshold>
+            <left_val>3.1025370582938194e-002</left_val>
+            <right_val>-2.7620419859886169e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 1 -1.</_>
+                <_>
+                  4 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.8443253189325333e-003</threshold>
+            <left_val>-6.9870138168334961e-001</left_val>
+            <right_val>5.1486968994140625e-002</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 2 3 -1.</_>
+                <_>
+                  8 13 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.6929589696228504e-003</threshold>
+            <left_val>-6.5479710698127747e-002</left_val>
+            <right_val>2.2728489711880684e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 3 2 -1.</_>
+                <_>
+                  4 13 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0892639867961407e-002</threshold>
+            <left_val>6.1733219772577286e-002</left_val>
+            <right_val>-6.7477071285247803e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 2 6 -1.</_>
+                <_>
+                  6 9 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2833529710769653e-001</threshold>
+            <left_val>2.1409809589385986e-001</left_val>
+            <right_val>-3.3962771296501160e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 12 6 -1.</_>
+                <_>
+                  0 17 12 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.1236700266599655e-002</threshold>
+            <left_val>1.5942020714282990e-001</left_val>
+            <right_val>-2.4341639876365662e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2321960180997849e-001</threshold>
+            <left_val>2.5586610659956932e-002</left_val>
+            <right_val>-4.7473230957984924e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 2 3 -1.</_>
+                <_>
+                  5 5 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9274000078439713e-003</threshold>
+            <left_val>1.0943879932165146e-001</left_val>
+            <right_val>-3.3568400144577026e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 3 -1.</_>
+                <_>
+                  5 6 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0102979615330696e-002</threshold>
+            <left_val>-5.1650160551071167e-001</left_val>
+            <right_val>2.9315050691366196e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 2 -1.</_>
+                <_>
+                  7 6 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.8281549215316772e-002</threshold>
+            <left_val>-6.4036741852760315e-002</left_val>
+            <right_val>6.2557631731033325e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 5 2 -1.</_>
+                <_>
+                  4 9 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4739660546183586e-003</threshold>
+            <left_val>-1.6827440261840820e-001</left_val>
+            <right_val>1.0941269993782043e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 3 5 -1.</_>
+                <_>
+                  1 4 1 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.0881707146763802e-003</threshold>
+            <left_val>2.4175269901752472e-001</left_val>
+            <right_val>-1.4523309469223022e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 2 3 8 -1.</_>
+                <_>
+                  10 2 1 8 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5073218643665314e-002</threshold>
+            <left_val>-7.3592007160186768e-001</left_val>
+            <right_val>5.9004039503633976e-003</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 3 8 -1.</_>
+                <_>
+                  1 2 1 8 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9067279994487762e-002</threshold>
+            <left_val>-1.0756839811801910e-001</left_val>
+            <right_val>3.3758550882339478e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 2 6 -1.</_>
+                <_>
+                  6 9 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.0190932154655457e-002</threshold>
+            <left_val>3.0061250925064087e-001</left_val>
+            <right_val>-4.3286528438329697e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 6 5 -1.</_>
+                <_>
+                  6 9 3 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4107230827212334e-002</threshold>
+            <left_val>1.4867919683456421e-001</left_val>
+            <right_val>-2.2179369628429413e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 12 -1.</_>
+                <_>
+                  11 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2285379022359848e-002</threshold>
+            <left_val>-2.0657710731029510e-001</left_val>
+            <right_val>2.4372029304504395e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 6 1 -1.</_>
+                <_>
+                  8 3 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.9224429503083229e-002</threshold>
+            <left_val>-4.1109448671340942e-001</left_val>
+            <right_val>8.8076941668987274e-002</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 1 3 -1.</_>
+                <_>
+                  7 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.8713049590587616e-002</threshold>
+            <left_val>-5.5512428283691406e-001</left_val>
+            <right_val>-3.5010900319321081e-005</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 12 3 1 -1.</_>
+                <_>
+                  5 13 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1740639805793762e-002</threshold>
+            <left_val>-7.4573528766632080e-001</left_val>
+            <right_val>4.6473011374473572e-002</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 2 2 18 -1.</_>
+                <_>
+                  7 2 1 18 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5142578184604645e-002</threshold>
+            <left_val>2.7216039597988129e-003</left_val>
+            <right_val>-4.9953749775886536e-001</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 2 18 -1.</_>
+                <_>
+                  4 2 1 18 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.6481479443609715e-003</threshold>
+            <left_val>1.9559350609779358e-001</left_val>
+            <right_val>-1.6296459734439850e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 15 1 3 -1.</_>
+                <_>
+                  7 16 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.3291230946779251e-003</threshold>
+            <left_val>-5.7543341070413589e-002</left_val>
+            <right_val>8.1424511969089508e-002</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 15 3 1 -1.</_>
+                <_>
+                  5 16 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.4579051211476326e-003</threshold>
+            <left_val>-5.4347038269042969e-001</left_val>
+            <right_val>5.7771220803260803e-002</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 14 2 2 -1.</_>
+                <_>
+                  8 14 1 1 2.</_>
+                <_>
+                  7 15 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0465289960848168e-004</threshold>
+            <left_val>-1.1724419891834259e-001</left_val>
+            <right_val>1.3367609679698944e-001</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 14 2 2 -1.</_>
+                <_>
+                  3 14 1 1 2.</_>
+                <_>
+                  4 15 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7040430102497339e-003</threshold>
+            <left_val>3.2203149795532227e-001</left_val>
+            <right_val>-1.0900110006332397e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 2 3 -1.</_>
+                <_>
+                  5 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.5647421181201935e-003</threshold>
+            <left_val>4.4239428639411926e-001</left_val>
+            <right_val>-6.8382248282432556e-002</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 2 -1.</_>
+                <_>
+                  7 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.0183129757642746e-003</threshold>
+            <left_val>-1.5239569544792175e-001</left_val>
+            <right_val>2.4483230710029602e-001</right_val></_></_>
+        <_>
+          <!-- tree 55 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 3 2 -1.</_>
+                <_>
+                  7 0 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0649990290403366e-002</threshold>
+            <left_val>-6.2405461072921753e-001</left_val>
+            <right_val>2.1711019799113274e-002</right_val></_></_>
+        <_>
+          <!-- tree 56 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 2 2 -1.</_>
+                <_>
+                  6 7 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4240309828892350e-003</threshold>
+            <left_val>8.9519590139389038e-002</left_val>
+            <right_val>-3.5850891470909119e-001</right_val></_></_>
+        <_>
+          <!-- tree 57 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 12 -1.</_>
+                <_>
+                  11 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9712692163884640e-003</threshold>
+            <left_val>-4.6914869546890259e-001</left_val>
+            <right_val>5.2607439458370209e-002</right_val></_></_>
+        <_>
+          <!-- tree 58 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 4 2 -1.</_>
+                <_>
+                  7 7 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.6963120549917221e-002</threshold>
+            <left_val>-6.1023771762847900e-002</left_val>
+            <right_val>5.7392549514770508e-001</right_val></_></_>
+        <_>
+          <!-- tree 59 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 3 2 -1.</_>
+                <_>
+                  7 0 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.1414969861507416e-003</threshold>
+            <left_val>2.8966020792722702e-002</left_val>
+            <right_val>-3.2176148891448975e-001</right_val></_></_>
+        <_>
+          <!-- tree 60 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 3 3 -1.</_>
+                <_>
+                  4 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.5924977213144302e-003</threshold>
+            <left_val>-7.2410070896148682e-001</left_val>
+            <right_val>4.0414128452539444e-002</right_val></_></_>
+        <_>
+          <!-- tree 61 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 4 1 3 -1.</_>
+                <_>
+                  11 5 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.1343858465552330e-003</threshold>
+            <left_val>-6.6965389251708984e-001</left_val>
+            <right_val>3.3574569970369339e-002</right_val></_></_>
+        <_>
+          <!-- tree 62 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 2 2 -1.</_>
+                <_>
+                  1 8 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4302479363977909e-003</threshold>
+            <left_val>-6.3991087675094604e-001</left_val>
+            <right_val>3.9288960397243500e-002</right_val></_></_>
+        <_>
+          <!-- tree 63 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 1 1 6 -1.</_>
+                <_>
+                  9 1 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.6460499502718449e-003</threshold>
+            <left_val>1.0181919671595097e-002</left_val>
+            <right_val>-1.8428249657154083e-001</right_val></_></_>
+        <_>
+          <!-- tree 64 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 1 6 1 -1.</_>
+                <_>
+                  3 1 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.3010810613632202e-002</threshold>
+            <left_val>-6.4822387695312500e-001</left_val>
+            <right_val>4.6115010976791382e-002</right_val></_></_></trees>
+      <stage_threshold>-1.3411600589752197e+000</stage_threshold>
+      <parent>18</parent>
+      <next>-1</next></_></stages></classifier_LeftEarA_trainNew2011_12_20>
+</opencv_storage>
diff --git a/data/haarcascades/haarcascade_mcs_rightear.xml b/data/haarcascades/haarcascade_mcs_rightear.xml
new file mode 100644
index 0000000000..eaf17b0d22
--- /dev/null
+++ b/data/haarcascades/haarcascade_mcs_rightear.xml
@@ -0,0 +1,9671 @@
+<?xml version="1.0"?>
+<!----------------------------------------------------------------------------
+  12x20 Right ear (in the image) detector computed with 5000 positive and 15000
+  negative samples
+
+//////////////////////////////////////////////////////////////////////////
+| Contributors License Agreement
+| 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.
+|
+| Copyright (c) 2011, Modesto Castrillon-Santana (IUSIANI, Universidad de
+| Las Palmas de Gran Canaria, Spain).
+|  All rights reserved.
+|
+| Redistribution and use in source and binary forms, with or without
+| modification, are permitted provided that the following conditions are
+| met:
+|
+|    * Redistributions of source code must retain the above copyright
+|       notice, this list of conditions and the following disclaimer.
+|    * Redistributions in binary form must reproduce the above
+|      copyright notice, this list of conditions and the following
+|      disclaimer in the documentation and/or other materials provided
+|      with the distribution.  
+|    * The name of Contributor may not 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
+| 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.  Back to
+| Top
+//////////////////////////////////////////////////////////////////////////
+
+RESEARCH USE:
+If you are using any of the detectors or involved ideas please cite this paper:
+
+@INPROCEEDINGS{Castrillon11-caepia,
+  author =       "Castrill\'on Santana, M. and Lorenzo Navarro, J. and Hern\'andez Sosa, D. ",
+  title =        "An Study on Ear Detection and its Applications to Face Detection",
+  booktitle =    "Conferencia de la Asociaci�n Espa�ola para la Inteligencia Artificial (CAEPIA)",
+  year =         "2011",
+  month =        "November",
+  address =      "La Laguna, Spain",
+  file = F
+}
+
+More information can be found at http://mozart.dis.ulpgc.es/Gias/modesto.html or in the paper.
+
+COMMERCIAL USE:
+If you have any commercial interest in this work please contact 
+mcastrillon@iusiani.ulpgc.es
+------------------------------------------------------------------------>
+<opencv_storage>
+<classifier_RightEarA_trainNew2011_12_20 type_id="opencv-haar-classifier">
+  <size>
+    12 20</size>
+  <stages>
+    <_>
+      <!-- stage 0 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 8 12 -1.</_>
+                <_>
+                  2 7 4 6 2.</_>
+                <_>
+                  6 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2393590062856674e-001</threshold>
+            <left_val>8.2578802108764648e-001</left_val>
+            <right_val>-6.7602032423019409e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 7 8 2 -1.</_>
+                <_>
+                  5 7 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.4228880479931831e-003</threshold>
+            <left_val>-1.2722210586071014e-001</left_val>
+            <right_val>3.3211699128150940e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  5 5 3 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1084940284490585e-002</threshold>
+            <left_val>5.6749510765075684e-001</left_val>
+            <right_val>-5.6716197729110718e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 8 18 -1.</_>
+                <_>
+                  4 9 8 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0189690589904785e-001</threshold>
+            <left_val>-7.6717972755432129e-001</left_val>
+            <right_val>1.9637049734592438e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 3 2 -1.</_>
+                <_>
+                  0 19 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.7402849304489791e-005</threshold>
+            <left_val>3.8455748558044434e-001</left_val>
+            <right_val>-6.7010718584060669e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 10 -1.</_>
+                <_>
+                  11 5 1 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.6445426568388939e-003</threshold>
+            <left_val>-6.9345837831497192e-001</left_val>
+            <right_val>1.0593380033969879e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 10 1 -1.</_>
+                <_>
+                  5 0 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.0770420784829184e-005</threshold>
+            <left_val>-6.8352818489074707e-001</left_val>
+            <right_val>3.5795739293098450e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3802499771118164e+000</stage_threshold>
+      <parent>-1</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 1 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 5 8 14 -1.</_>
+                <_>
+                  2 5 4 7 2.</_>
+                <_>
+                  6 12 4 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8316349387168884e-001</threshold>
+            <left_val>7.8830862045288086e-001</left_val>
+            <right_val>-5.8876812458038330e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 8 -1.</_>
+                <_>
+                  0 4 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5380790233612061e-002</threshold>
+            <left_val>-7.4764448404312134e-001</left_val>
+            <right_val>4.1486009955406189e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 6 10 -1.</_>
+                <_>
+                  2 12 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4207419939339161e-002</threshold>
+            <left_val>-7.8411531448364258e-001</left_val>
+            <right_val>2.7354270219802856e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 2 4 8 -1.</_>
+                <_>
+                  10 2 2 4 2.</_>
+                <_>
+                  8 6 2 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.6809601634740829e-003</threshold>
+            <left_val>-1.0974329710006714e-001</left_val>
+            <right_val>9.4718709588050842e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 4 8 -1.</_>
+                <_>
+                  0 2 2 4 2.</_>
+                <_>
+                  2 6 2 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.1219559498131275e-003</threshold>
+            <left_val>3.1739580631256104e-001</left_val>
+            <right_val>-5.4334312677383423e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 1 2.</_>
+                <_>
+                  0 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1700070463120937e-002</threshold>
+            <left_val>3.9653539657592773e-001</left_val>
+            <right_val>-3.7434050440788269e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 12 6 -1.</_>
+                <_>
+                  6 14 6 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.8762829303741455e-001</threshold>
+            <left_val>-1.7733460664749146e-001</left_val>
+            <right_val>8.8516682386398315e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 2 6 -1.</_>
+                <_>
+                  6 12 2 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.8463501036167145e-002</threshold>
+            <left_val>-6.0947227478027344e-001</left_val>
+            <right_val>1.3633400201797485e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 6 2 -1.</_>
+                <_>
+                  6 12 3 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.6523773372173309e-002</threshold>
+            <left_val>-2.9950559139251709e-001</left_val>
+            <right_val>6.1522072553634644e-001</right_val></_></_></trees>
+      <stage_threshold>-1.4652169942855835e+000</stage_threshold>
+      <parent>0</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 2 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  8 10 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1777380108833313e-001</threshold>
+            <left_val>-5.8754861354827881e-001</left_val>
+            <right_val>6.1994218826293945e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 9 3 -1.</_>
+                <_>
+                  6 7 3 1 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9533330351114273e-002</threshold>
+            <left_val>-4.2420691251754761e-001</left_val>
+            <right_val>3.6524820327758789e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 12 -1.</_>
+                <_>
+                  0 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.1603458598256111e-003</threshold>
+            <left_val>-7.9607379436492920e-001</left_val>
+            <right_val>3.2861700654029846e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 2 4 5 -1.</_>
+                <_>
+                  6 2 2 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.9753831010311842e-005</threshold>
+            <left_val>1.0398519784212112e-001</left_val>
+            <right_val>-4.5819509029388428e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 4 4 -1.</_>
+                <_>
+                  4 7 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.6190438549965620e-004</threshold>
+            <left_val>5.3506380319595337e-001</left_val>
+            <right_val>-6.4719748497009277e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 4 -1.</_>
+                <_>
+                  8 2 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0906500518321991e-002</threshold>
+            <left_val>-1.6793949902057648e-001</left_val>
+            <right_val>2.4539050459861755e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 3 20 -1.</_>
+                <_>
+                  3 10 3 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.2527771592140198e-003</threshold>
+            <left_val>-8.5986042022705078e-001</left_val>
+            <right_val>2.2863869369029999e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 16 3 4 -1.</_>
+                <_>
+                  9 17 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9341029264032841e-003</threshold>
+            <left_val>-4.6319939196109772e-002</left_val>
+            <right_val>-6.0758531093597412e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 4 -1.</_>
+                <_>
+                  0 2 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8554080452304333e-004</threshold>
+            <left_val>-5.7996147871017456e-001</left_val>
+            <right_val>3.7694430351257324e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 16 3 4 -1.</_>
+                <_>
+                  9 17 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.2531788609921932e-003</threshold>
+            <left_val>-5.6681227684020996e-001</left_val>
+            <right_val>-1.9910290837287903e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 3 4 -1.</_>
+                <_>
+                  0 17 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.0826769691193476e-005</threshold>
+            <left_val>-6.2813758850097656e-001</left_val>
+            <right_val>4.0546119213104248e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 7 8 1 -1.</_>
+                <_>
+                  5 7 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0268500074744225e-002</threshold>
+            <left_val>4.5032399892807007e-001</left_val>
+            <right_val>-2.7399060130119324e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 9 6 -1.</_>
+                <_>
+                  3 6 3 2 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.5408639814704657e-003</threshold>
+            <left_val>3.4393149614334106e-001</left_val>
+            <right_val>-6.7639619112014771e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  8 15 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.9421626627445221e-002</threshold>
+            <left_val>6.5173202753067017e-001</left_val>
+            <right_val>-7.4326410889625549e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  4 15 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.1986039984039962e-005</threshold>
+            <left_val>-4.5737218856811523e-001</left_val>
+            <right_val>3.0109271407127380e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 3 9 2 -1.</_>
+                <_>
+                  2 4 9 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.3741732446942478e-005</threshold>
+            <left_val>-5.5820369720458984e-001</left_val>
+            <right_val>1.9148319959640503e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 1 4 -1.</_>
+                <_>
+                  0 8 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.4920871005160734e-005</threshold>
+            <left_val>-5.7379388809204102e-001</left_val>
+            <right_val>2.1276189386844635e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 7 10 -1.</_>
+                <_>
+                  4 13 7 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3159319758415222e-001</threshold>
+            <left_val>-2.2754240036010742e-001</left_val>
+            <right_val>2.8766331076622009e-001</right_val></_></_></trees>
+      <stage_threshold>-2.0372869968414307e+000</stage_threshold>
+      <parent>1</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 3 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 8 12 -1.</_>
+                <_>
+                  2 7 4 6 2.</_>
+                <_>
+                  6 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5496319532394409e-001</threshold>
+            <left_val>7.2985649108886719e-001</left_val>
+            <right_val>-5.9489607810974121e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  7 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.4833214059472084e-003</threshold>
+            <left_val>1.3606220483779907e-001</left_val>
+            <right_val>-4.3773031234741211e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  5 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.2831680029630661e-002</threshold>
+            <left_val>6.7158091068267822e-001</left_val>
+            <right_val>-2.8739199042320251e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 16 4 4 -1.</_>
+                <_>
+                  5 18 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8853790834546089e-002</threshold>
+            <left_val>4.5923650264739990e-001</left_val>
+            <right_val>-4.9327030777931213e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 3 -1.</_>
+                <_>
+                  6 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7052419483661652e-001</threshold>
+            <left_val>-1.6527549922466278e-001</left_val>
+            <right_val>8.4507262706756592e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 15 12 3 -1.</_>
+                <_>
+                  0 15 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0879129916429520e-001</threshold>
+            <left_val>-2.8913050889968872e-001</left_val>
+            <right_val>5.3111201524734497e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 16 -1.</_>
+                <_>
+                  0 4 2 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0960019212216139e-003</threshold>
+            <left_val>-5.5323868989944458e-001</left_val>
+            <right_val>2.6134639978408813e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 8 13 -1.</_>
+                <_>
+                  2 0 4 13 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.3618099987506866e-002</threshold>
+            <left_val>2.2911429405212402e-001</left_val>
+            <right_val>-5.5924427509307861e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 6 2 -1.</_>
+                <_>
+                  0 1 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1074040085077286e-003</threshold>
+            <left_val>-6.3096380233764648e-001</left_val>
+            <right_val>1.5855440497398376e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 18 5 2 -1.</_>
+                <_>
+                  7 19 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4385627843439579e-003</threshold>
+            <left_val>-6.3817399740219116e-001</left_val>
+            <right_val>1.2779480218887329e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 5 2 -1.</_>
+                <_>
+                  0 19 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.4127003103494644e-003</threshold>
+            <left_val>3.5108420252799988e-001</left_val>
+            <right_val>-3.4738400578498840e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 15 2 3 -1.</_>
+                <_>
+                  6 15 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.2499480992555618e-002</threshold>
+            <left_val>6.7672997713088989e-001</left_val>
+            <right_val>-5.5984470993280411e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 15 3 2 -1.</_>
+                <_>
+                  6 15 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.3464169576764107e-002</threshold>
+            <left_val>-7.5412607192993164e-001</left_val>
+            <right_val>1.5986099839210510e-001</right_val></_></_></trees>
+      <stage_threshold>-1.5061739683151245e+000</stage_threshold>
+      <parent>2</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 4 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 7 8 12 -1.</_>
+                <_>
+                  2 7 4 6 2.</_>
+                <_>
+                  6 13 4 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8050560355186462e-001</threshold>
+            <left_val>7.1835839748382568e-001</left_val>
+            <right_val>-5.2469527721405029e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 16 4 4 -1.</_>
+                <_>
+                  5 18 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5271560288965702e-002</threshold>
+            <left_val>3.2215949892997742e-001</left_val>
+            <right_val>-1.5855640172958374e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  4 5 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.4879799932241440e-002</threshold>
+            <left_val>3.2105189561843872e-001</left_val>
+            <right_val>-5.3338629007339478e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 12 4 -1.</_>
+                <_>
+                  6 16 6 2 2.</_>
+                <_>
+                  0 18 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1743600964546204e-002</threshold>
+            <left_val>4.1040870547294617e-001</left_val>
+            <right_val>-3.7935909628868103e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 10 4 -1.</_>
+                <_>
+                  0 4 10 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.8427619040012360e-003</threshold>
+            <left_val>-6.9584208726882935e-001</left_val>
+            <right_val>2.4080069363117218e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 2 8 -1.</_>
+                <_>
+                  6 11 2 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.9639631062746048e-002</threshold>
+            <left_val>8.0581977963447571e-003</left_val>
+            <right_val>-5.4770648479461670e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 8 3 -1.</_>
+                <_>
+                  6 11 4 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1154930293560028e-001</threshold>
+            <left_val>-2.4036459624767303e-001</left_val>
+            <right_val>5.6387817859649658e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 1 6 -1.</_>
+                <_>
+                  6 12 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.6947790756821632e-002</threshold>
+            <left_val>-4.5162969827651978e-001</left_val>
+            <right_val>6.0060828924179077e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 6 1 -1.</_>
+                <_>
+                  6 12 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.9296129494905472e-002</threshold>
+            <left_val>8.3912831544876099e-001</left_val>
+            <right_val>-1.8871270120143890e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 1 4 10 -1.</_>
+                <_>
+                  10 1 2 5 2.</_>
+                <_>
+                  8 6 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.8315439820289612e-002</threshold>
+            <left_val>6.9766468368470669e-003</left_val>
+            <right_val>1.8534269928932190e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 12 -1.</_>
+                <_>
+                  0 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.3421538770198822e-002</threshold>
+            <left_val>-3.1101679801940918e-001</left_val>
+            <right_val>4.0044930577278137e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 2 1 -1.</_>
+                <_>
+                  9 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.2644667923450470e-003</threshold>
+            <left_val>-4.4615790247917175e-001</left_val>
+            <right_val>6.6276572644710541e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 1 2 -1.</_>
+                <_>
+                  3 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5548560079187155e-003</threshold>
+            <left_val>1.3413320481777191e-001</left_val>
+            <right_val>-7.4927258491516113e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  7 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.9710179194808006e-002</threshold>
+            <left_val>6.1377300880849361e-004</left_val>
+            <right_val>-7.7615362405776978e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  5 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.1485700756311417e-002</threshold>
+            <left_val>5.9405767917633057e-001</left_val>
+            <right_val>-1.6889290511608124e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 2 2 3 -1.</_>
+                <_>
+                  10 3 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2231590226292610e-002</threshold>
+            <left_val>5.1312480121850967e-002</left_val>
+            <right_val>-7.5303572416305542e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 2 3 -1.</_>
+                <_>
+                  0 3 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3153190053999424e-003</threshold>
+            <left_val>-6.4812111854553223e-001</left_val>
+            <right_val>1.3281610608100891e-001</right_val></_></_></trees>
+      <stage_threshold>-1.5266020298004150e+000</stage_threshold>
+      <parent>3</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 5 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 8 4 -1.</_>
+                <_>
+                  6 10 4 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1714699864387512e-001</threshold>
+            <left_val>-5.1155489683151245e-001</left_val>
+            <right_val>5.4587250947952271e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 9 3 -1.</_>
+                <_>
+                  6 7 3 1 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.2537951618432999e-002</threshold>
+            <left_val>-2.6988661289215088e-001</left_val>
+            <right_val>3.4098041057586670e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 4 10 -1.</_>
+                <_>
+                  0 1 2 5 2.</_>
+                <_>
+                  2 6 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9980749115347862e-002</threshold>
+            <left_val>3.5662230849266052e-001</left_val>
+            <right_val>-4.4640049338340759e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 3 8 17 -1.</_>
+                <_>
+                  5 3 4 17 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2166350334882736e-001</threshold>
+            <left_val>4.5662569999694824e-001</left_val>
+            <right_val>-6.7647598683834076e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 8 -1.</_>
+                <_>
+                  6 0 2 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6176940873265266e-002</threshold>
+            <left_val>-4.8407769203186035e-001</left_val>
+            <right_val>2.5647491216659546e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 3 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2731030583381653e-001</threshold>
+            <left_val>7.8568279743194580e-001</left_val>
+            <right_val>-7.6182372868061066e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 4 2 -1.</_>
+                <_>
+                  0 19 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.7296859081834555e-003</threshold>
+            <left_val>2.7144059538841248e-001</left_val>
+            <right_val>-4.8822438716888428e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 3 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7392159998416901e-001</threshold>
+            <left_val>7.3156762123107910e-001</left_val>
+            <right_val>-4.0217950940132141e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 6 9 3 -1.</_>
+                <_>
+                  4 7 3 1 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.4516716897487640e-002</threshold>
+            <left_val>4.9297851324081421e-001</left_val>
+            <right_val>-2.1850970387458801e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 3 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.9759500920772552e-002</threshold>
+            <left_val>-1.0667549818754196e-001</left_val>
+            <right_val>2.1722890436649323e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 3 6 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.9159070923924446e-002</threshold>
+            <left_val>1.5513190627098083e-001</left_val>
+            <right_val>-7.9432719945907593e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 10 -1.</_>
+                <_>
+                  0 5 12 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.8567609414458275e-003</threshold>
+            <left_val>-7.7142190933227539e-001</left_val>
+            <right_val>1.0970850288867950e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 1 2 -1.</_>
+                <_>
+                  2 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.6352910790592432e-003</threshold>
+            <left_val>9.6235923469066620e-002</left_val>
+            <right_val>-7.4925291538238525e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 4 8 -1.</_>
+                <_>
+                  4 7 4 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.1161300614476204e-003</threshold>
+            <left_val>1.7448060214519501e-001</left_val>
+            <right_val>-4.6480000019073486e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 3 -1.</_>
+                <_>
+                  1 0 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7307260315865278e-003</threshold>
+            <left_val>-5.8561611175537109e-001</left_val>
+            <right_val>1.1779639869928360e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 12 4 -1.</_>
+                <_>
+                  0 9 12 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9059289246797562e-002</threshold>
+            <left_val>-6.8809962272644043e-001</left_val>
+            <right_val>1.0283970087766647e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 3 1 3 -1.</_>
+                <_>
+                  1 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.9182219877839088e-003</threshold>
+            <left_val>-6.6901868581771851e-001</left_val>
+            <right_val>8.3721928298473358e-002</right_val></_></_></trees>
+      <stage_threshold>-1.4295140504837036e+000</stage_threshold>
+      <parent>4</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 6 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 8 2 -1.</_>
+                <_>
+                  6 11 4 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.1108748912811279e-002</threshold>
+            <left_val>-3.9180481433868408e-001</left_val>
+            <right_val>5.3625607490539551e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 3 2 6 -1.</_>
+                <_>
+                  5 5 2 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.1598061844706535e-003</threshold>
+            <left_val>-4.6528929471969604e-001</left_val>
+            <right_val>3.3383831381797791e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 8 -1.</_>
+                <_>
+                  0 4 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.0795027315616608e-004</threshold>
+            <left_val>-7.5230997800827026e-001</left_val>
+            <right_val>1.4381100237369537e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 5 8 14 -1.</_>
+                <_>
+                  6 5 4 7 2.</_>
+                <_>
+                  2 12 4 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4406640231609344e-001</threshold>
+            <left_val>-2.2846619784832001e-001</left_val>
+            <right_val>5.0088721513748169e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 1 8 -1.</_>
+                <_>
+                  0 8 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.9084907560609281e-005</threshold>
+            <left_val>-4.9552011489868164e-001</left_val>
+            <right_val>2.3163549602031708e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 3 -1.</_>
+                <_>
+                  0 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6304260492324829e-001</threshold>
+            <left_val>8.0807077884674072e-001</left_val>
+            <right_val>-1.4503139257431030e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 2 3 -1.</_>
+                <_>
+                  4 1 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.9489316344261169e-003</threshold>
+            <left_val>-1.3804569840431213e-001</left_val>
+            <right_val>6.0897988080978394e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 12 6 8 -1.</_>
+                <_>
+                  5 14 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.6701432466506958e-002</threshold>
+            <left_val>3.7772629410028458e-002</left_val>
+            <right_val>-5.3447282314300537e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 4 9 -1.</_>
+                <_>
+                  3 14 4 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.7309949994087219e-002</threshold>
+            <left_val>-3.6191630363464355e-001</left_val>
+            <right_val>2.8269779682159424e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 10 16 -1.</_>
+                <_>
+                  2 8 10 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.2022439166903496e-002</threshold>
+            <left_val>-5.2068692445755005e-001</left_val>
+            <right_val>9.4968706369400024e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 15 3 2 -1.</_>
+                <_>
+                  5 15 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3980070129036903e-002</threshold>
+            <left_val>1.1217589676380157e-001</left_val>
+            <right_val>-6.8278092145919800e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 15 4 1 -1.</_>
+                <_>
+                  9 16 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.6961131989955902e-002</threshold>
+            <left_val>8.7730789184570313e-001</left_val>
+            <right_val>-2.7844179421663284e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 15 1 4 -1.</_>
+                <_>
+                  3 16 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1592600494623184e-003</threshold>
+            <left_val>-3.4661638736724854e-001</left_val>
+            <right_val>2.0498119294643402e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 14 3 3 -1.</_>
+                <_>
+                  7 15 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9640380516648293e-002</threshold>
+            <left_val>-1.2608189880847931e-001</left_val>
+            <right_val>2.8791791200637817e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 14 3 3 -1.</_>
+                <_>
+                  5 15 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0507949627935886e-002</threshold>
+            <left_val>-6.1253058910369873e-001</left_val>
+            <right_val>1.2488999962806702e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 8 2 -1.</_>
+                <_>
+                  5 6 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7976740375161171e-002</threshold>
+            <left_val>-1.2991739809513092e-001</left_val>
+            <right_val>1.4235779643058777e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 6 17 -1.</_>
+                <_>
+                  5 2 2 17 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1597379595041275e-002</threshold>
+            <left_val>3.3326789736747742e-001</left_val>
+            <right_val>-2.4774129688739777e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8917859997600317e-003</threshold>
+            <left_val>-5.3087908029556274e-001</left_val>
+            <right_val>8.8928163051605225e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 14 4 2 -1.</_>
+                <_>
+                  6 14 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7453400418162346e-002</threshold>
+            <left_val>-6.4604520797729492e-001</left_val>
+            <right_val>1.1086379736661911e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 8 1 -1.</_>
+                <_>
+                  3 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0619490407407284e-002</threshold>
+            <left_val>1.4190349727869034e-002</left_val>
+            <right_val>-2.1650099754333496e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 2 -1.</_>
+                <_>
+                  0 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1998750269412994e-003</threshold>
+            <left_val>-6.4023351669311523e-001</left_val>
+            <right_val>1.0543160140514374e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  7 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.0056620538234711e-003</threshold>
+            <left_val>6.6442847251892090e-002</left_val>
+            <right_val>-3.8506388664245605e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 3 -1.</_>
+                <_>
+                  5 5 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.1365811824798584e-002</threshold>
+            <left_val>4.9019768834114075e-001</left_val>
+            <right_val>-1.3340839743614197e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 2 -1.</_>
+                <_>
+                  10 0 2 1 2.</_>
+                <_>
+                  8 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8146664202213287e-003</threshold>
+            <left_val>-7.5805522501468658e-002</left_val>
+            <right_val>5.1142227649688721e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 2 -1.</_>
+                <_>
+                  0 0 2 1 2.</_>
+                <_>
+                  2 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4432060308754444e-003</threshold>
+            <left_val>-5.3494578599929810e-001</left_val>
+            <right_val>1.3186639547348022e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 3 -1.</_>
+                <_>
+                  8 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.3595509827136993e-002</threshold>
+            <left_val>1.8829340115189552e-002</left_val>
+            <right_val>-8.7616902589797974e-001</right_val></_></_></trees>
+      <stage_threshold>-1.5588049888610840e+000</stage_threshold>
+      <parent>5</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 7 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 5 8 14 -1.</_>
+                <_>
+                  2 5 4 7 2.</_>
+                <_>
+                  6 12 4 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9901029765605927e-001</threshold>
+            <left_val>4.1589239239692688e-001</left_val>
+            <right_val>-4.6403810381889343e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 7 4 1 -1.</_>
+                <_>
+                  7 7 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0957729537039995e-003</threshold>
+            <left_val>-2.7428150177001953e-001</left_val>
+            <right_val>2.1992009878158569e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 1 3 -1.</_>
+                <_>
+                  5 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5783050116151571e-003</threshold>
+            <left_val>-2.5449270009994507e-001</left_val>
+            <right_val>5.4316788911819458e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 6 4 1 -1.</_>
+                <_>
+                  8 6 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.5569820553064346e-002</threshold>
+            <left_val>4.2951688170433044e-002</left_val>
+            <right_val>-6.6588342189788818e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 1 4 -1.</_>
+                <_>
+                  4 6 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.8403531070798635e-003</threshold>
+            <left_val>1.9703429937362671e-001</left_val>
+            <right_val>-5.4586201906204224e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 1 7 9 -1.</_>
+                <_>
+                  3 4 7 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9690821431577206e-003</threshold>
+            <left_val>-5.1554411649703979e-001</left_val>
+            <right_val>2.2360439598560333e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 9 6 3 -1.</_>
+                <_>
+                  3 9 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.4965478852391243e-003</threshold>
+            <left_val>1.5371499955654144e-001</left_val>
+            <right_val>-6.1535251140594482e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 18 10 2 -1.</_>
+                <_>
+                  7 18 5 1 2.</_>
+                <_>
+                  2 19 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.9704096317291260e-003</threshold>
+            <left_val>1.8355900049209595e-001</left_val>
+            <right_val>-2.8429880738258362e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  6 13 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.6080069392919540e-002</threshold>
+            <left_val>7.7755087614059448e-001</left_val>
+            <right_val>-9.8359443247318268e-002</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 2 3 -1.</_>
+                <_>
+                  8 5 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0908209718763828e-002</threshold>
+            <left_val>6.3484668731689453e-002</left_val>
+            <right_val>-6.9791257381439209e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 3 2 -1.</_>
+                <_>
+                  4 5 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.8930671811103821e-003</threshold>
+            <left_val>4.0726318955421448e-001</left_val>
+            <right_val>-2.5781801342964172e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 12 5 -1.</_>
+                <_>
+                  0 14 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8678830564022064e-001</threshold>
+            <left_val>-2.7086579799652100e-001</left_val>
+            <right_val>3.6147558689117432e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 8 2 -1.</_>
+                <_>
+                  5 0 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.4373157480731606e-004</threshold>
+            <left_val>-5.8118808269500732e-001</left_val>
+            <right_val>1.5266190469264984e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 2 2 -1.</_>
+                <_>
+                  6 16 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.6823019608855247e-002</threshold>
+            <left_val>7.3039489984512329e-001</left_val>
+            <right_val>-5.7183459401130676e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 16 2 2 -1.</_>
+                <_>
+                  6 16 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.4266774356365204e-003</threshold>
+            <left_val>-6.9740217924118042e-001</left_val>
+            <right_val>1.1783199757337570e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 1 6 -1.</_>
+                <_>
+                  4 11 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.4732030481100082e-002</threshold>
+            <left_val>-6.6901608370244503e-003</left_val>
+            <right_val>-3.9551690220832825e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 6 1 -1.</_>
+                <_>
+                  8 11 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9846759736537933e-002</threshold>
+            <left_val>-2.5491309165954590e-001</left_val>
+            <right_val>2.6959219574928284e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 1 3 -1.</_>
+                <_>
+                  10 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1466080322861671e-003</threshold>
+            <left_val>-4.7784709930419922e-001</left_val>
+            <right_val>1.4147639274597168e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 17 1 3 -1.</_>
+                <_>
+                  1 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.8631740547716618e-004</threshold>
+            <left_val>-2.9782509803771973e-001</left_val>
+            <right_val>2.1989880502223969e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 2 1 18 -1.</_>
+                <_>
+                  11 8 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3526080548763275e-001</threshold>
+            <left_val>7.3641002178192139e-001</left_val>
+            <right_val>-3.6679711192846298e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 20 -1.</_>
+                <_>
+                  0 5 1 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4555889647454023e-003</threshold>
+            <left_val>-4.9741968512535095e-001</left_val>
+            <right_val>1.4351129531860352e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 6 2 -1.</_>
+                <_>
+                  7 0 3 1 2.</_>
+                <_>
+                  4 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3439180329442024e-002</threshold>
+            <left_val>4.4307011365890503e-001</left_val>
+            <right_val>-6.1504751443862915e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 2 3 -1.</_>
+                <_>
+                  0 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.8535612188279629e-003</threshold>
+            <left_val>8.6272820830345154e-002</left_val>
+            <right_val>-6.9572478532791138e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 2 1 -1.</_>
+                <_>
+                  8 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.6728219129145145e-003</threshold>
+            <left_val>-2.4009980261325836e-001</left_val>
+            <right_val>7.2359912097454071e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 3 4 2 -1.</_>
+                <_>
+                  3 4 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.8104060329496861e-003</threshold>
+            <left_val>-2.8405401110649109e-001</left_val>
+            <right_val>2.0643989741802216e-001</right_val></_></_></trees>
+      <stage_threshold>-1.5198639631271362e+000</stage_threshold>
+      <parent>6</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 8 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 2 -1.</_>
+                <_>
+                  6 5 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.6374010592699051e-002</threshold>
+            <left_val>-3.7089619040489197e-001</left_val>
+            <right_val>5.0737190246582031e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 12 5 -1.</_>
+                <_>
+                  3 12 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.4187058508396149e-002</threshold>
+            <left_val>-3.1576469540596008e-001</left_val>
+            <right_val>4.0862488746643066e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 10 2 -1.</_>
+                <_>
+                  0 18 5 1 2.</_>
+                <_>
+                  5 19 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1773589998483658e-002</threshold>
+            <left_val>-3.5064500570297241e-001</left_val>
+            <right_val>3.1217798590660095e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 3 8 13 -1.</_>
+                <_>
+                  5 3 4 13 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0922340303659439e-001</threshold>
+            <left_val>-1.2247060239315033e-001</left_val>
+            <right_val>2.5683128833770752e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 3 8 13 -1.</_>
+                <_>
+                  3 3 4 13 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.6653150133788586e-003</threshold>
+            <left_val>2.3083719611167908e-001</left_val>
+            <right_val>-4.8135739564895630e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 4 -1.</_>
+                <_>
+                  11 0 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.5095751993358135e-003</threshold>
+            <left_val>1.6601459681987762e-001</left_val>
+            <right_val>-1.2917369604110718e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 10 2 -1.</_>
+                <_>
+                  0 1 5 1 2.</_>
+                <_>
+                  5 2 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1136589571833611e-002</threshold>
+            <left_val>3.8687920570373535e-001</left_val>
+            <right_val>-2.2618110477924347e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 8 5 -1.</_>
+                <_>
+                  4 11 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5101970732212067e-001</threshold>
+            <left_val>7.8407418727874756e-001</left_val>
+            <right_val>-5.6705389171838760e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 14 -1.</_>
+                <_>
+                  0 7 1 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5842441022396088e-002</threshold>
+            <left_val>-3.3353409171104431e-001</left_val>
+            <right_val>2.6884201169013977e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 4 6 -1.</_>
+                <_>
+                  6 12 4 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.0237798839807510e-002</threshold>
+            <left_val>6.6777043044567108e-002</left_val>
+            <right_val>-5.8397102355957031e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 10 6 4 -1.</_>
+                <_>
+                  6 12 2 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.8902626633644104e-002</threshold>
+            <left_val>-3.2930138707160950e-001</left_val>
+            <right_val>2.3172050714492798e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 2 -1.</_>
+                <_>
+                  0 17 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1977110058069229e-001</threshold>
+            <left_val>7.2716677188873291e-001</left_val>
+            <right_val>-1.0525380074977875e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 6 3 3 -1.</_>
+                <_>
+                  4 7 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.8936740234494209e-002</threshold>
+            <left_val>-1.3431450724601746e-001</left_val>
+            <right_val>5.6203877925872803e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 6 4 -1.</_>
+                <_>
+                  6 9 3 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.3808198571205139e-002</threshold>
+            <left_val>-4.9557849764823914e-002</left_val>
+            <right_val>1.0450640320777893e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 4 6 -1.</_>
+                <_>
+                  6 9 4 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.3902268856763840e-002</threshold>
+            <left_val>9.9094279110431671e-002</left_val>
+            <right_val>-7.6239812374114990e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 1 -1.</_>
+                <_>
+                  10 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.1007126718759537e-003</threshold>
+            <left_val>-4.3555849790573120e-001</left_val>
+            <right_val>2.2304659709334373e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 1 2 -1.</_>
+                <_>
+                  2 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4974169209599495e-003</threshold>
+            <left_val>9.3714617192745209e-002</left_val>
+            <right_val>-6.8376600742340088e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0426550172269344e-002</threshold>
+            <left_val>-1.1307760328054428e-001</left_val>
+            <right_val>4.3951630592346191e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 4 -1.</_>
+                <_>
+                  1 0 1 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4919810239225626e-003</threshold>
+            <left_val>-4.9109318852424622e-001</left_val>
+            <right_val>1.2399309873580933e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4614528305828571e-003</threshold>
+            <left_val>3.4285509586334229e-001</left_val>
+            <right_val>-1.3288980722427368e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 3 2 -1.</_>
+                <_>
+                  2 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.9255861453711987e-003</threshold>
+            <left_val>4.0674179792404175e-001</left_val>
+            <right_val>-1.4747169613838196e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 1 4 1 -1.</_>
+                <_>
+                  9 2 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4747819863259792e-002</threshold>
+            <left_val>-1.7921010032296181e-002</left_val>
+            <right_val>1.5927059948444366e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 1 4 -1.</_>
+                <_>
+                  3 2 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.8200701177120209e-003</threshold>
+            <left_val>8.6944580078125000e-002</left_val>
+            <right_val>-6.7220121622085571e-001</right_val></_></_></trees>
+      <stage_threshold>-1.2744859457015991e+000</stage_threshold>
+      <parent>7</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 9 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 12 4 -1.</_>
+                <_>
+                  0 4 12 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0345980077981949e-002</threshold>
+            <left_val>-5.6813991069793701e-001</left_val>
+            <right_val>2.7571758627891541e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 8 -1.</_>
+                <_>
+                  6 11 3 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.5385681092739105e-002</threshold>
+            <left_val>-5.6568390130996704e-001</left_val>
+            <right_val>4.2446270585060120e-002</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 6 8 14 -1.</_>
+                <_>
+                  2 6 4 7 2.</_>
+                <_>
+                  6 13 4 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4006670713424683e-001</threshold>
+            <left_val>3.9162129163742065e-001</left_val>
+            <right_val>-3.0378338694572449e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 18 1 2 -1.</_>
+                <_>
+                  11 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0817600414156914e-003</threshold>
+            <left_val>-7.0329940319061279e-001</left_val>
+            <right_val>1.1626099795103073e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 2 2 -1.</_>
+                <_>
+                  0 19 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6060429625213146e-003</threshold>
+            <left_val>2.2388499975204468e-001</left_val>
+            <right_val>-4.8557040095329285e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0570240020751953e-001</threshold>
+            <left_val>-7.4889171123504639e-001</left_val>
+            <right_val>2.8992230072617531e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 4 4 -1.</_>
+                <_>
+                  4 7 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3500300012528896e-003</threshold>
+            <left_val>2.3428779840469360e-001</left_val>
+            <right_val>-4.2647179961204529e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 2 3 -1.</_>
+                <_>
+                  7 1 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.1817590147256851e-002</threshold>
+            <left_val>-8.9189022779464722e-001</left_val>
+            <right_val>-1.0216370224952698e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 3 2 -1.</_>
+                <_>
+                  5 1 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.4469848982989788e-003</threshold>
+            <left_val>-2.6281470060348511e-001</left_val>
+            <right_val>3.1677961349487305e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 7 1 2 -1.</_>
+                <_>
+                  11 8 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.7602698691189289e-003</threshold>
+            <left_val>-7.9144752025604248e-001</left_val>
+            <right_val>1.2072199955582619e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 1 2 -1.</_>
+                <_>
+                  0 8 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.8887082054279745e-005</threshold>
+            <left_val>-4.4443818926811218e-001</left_val>
+            <right_val>1.9887650012969971e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 8 8 -1.</_>
+                <_>
+                  6 0 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.4817398786544800e-002</threshold>
+            <left_val>-2.3440040647983551e-001</left_val>
+            <right_val>2.8372839093208313e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 12 7 -1.</_>
+                <_>
+                  6 12 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9690501093864441e-001</threshold>
+            <left_val>-1.1379630118608475e-001</left_val>
+            <right_val>8.4734469652175903e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 2 1 -1.</_>
+                <_>
+                  8 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2669449672102928e-002</threshold>
+            <left_val>-5.3791618347167969e-001</left_val>
+            <right_val>5.0364010035991669e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 1 2 -1.</_>
+                <_>
+                  4 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.2963419798761606e-003</threshold>
+            <left_val>9.5009326934814453e-002</left_val>
+            <right_val>-6.9295811653137207e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 2 6 -1.</_>
+                <_>
+                  4 12 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.1940039992332458e-002</threshold>
+            <left_val>6.4861620776355267e-003</left_val>
+            <right_val>-4.8242160677909851e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 1 3 -1.</_>
+                <_>
+                  0 5 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.5874840579926968e-003</threshold>
+            <left_val>7.4269242584705353e-002</left_val>
+            <right_val>-8.5056728124618530e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 8 3 4 -1.</_>
+                <_>
+                  10 8 1 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3228190131485462e-002</threshold>
+            <left_val>-1.8141390383243561e-001</left_val>
+            <right_val>5.5488282442092896e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 1 2 -1.</_>
+                <_>
+                  0 7 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.3280639955773950e-005</threshold>
+            <left_val>-3.5342589020729065e-001</left_val>
+            <right_val>1.6182580590248108e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 6 12 -1.</_>
+                <_>
+                  4 7 6 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.3232236802577972e-002</threshold>
+            <left_val>3.6166220903396606e-002</left_val>
+            <right_val>-3.9560291171073914e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 16 4 4 -1.</_>
+                <_>
+                  3 18 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7989000305533409e-002</threshold>
+            <left_val>1.8585060536861420e-001</left_val>
+            <right_val>-2.9997050762176514e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  7 4 1 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.5582181811332703e-002</threshold>
+            <left_val>-2.3212260566651821e-003</left_val>
+            <right_val>-7.5706237554550171e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  5 4 6 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4874819666147232e-002</threshold>
+            <left_val>-2.1825970709323883e-001</left_val>
+            <right_val>2.7366569638252258e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 3 -1.</_>
+                <_>
+                  8 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.0184369757771492e-002</threshold>
+            <left_val>3.5116590559482574e-002</left_val>
+            <right_val>-4.5619380474090576e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 3 -1.</_>
+                <_>
+                  4 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4273890294134617e-002</threshold>
+            <left_val>-1.2478730082511902e-001</left_val>
+            <right_val>6.1065578460693359e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 6 -1.</_>
+                <_>
+                  11 3 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6945620775222778e-002</threshold>
+            <left_val>-5.6217260658740997e-002</left_val>
+            <right_val>4.3960160017013550e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 6 16 -1.</_>
+                <_>
+                  0 12 6 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4722250401973724e-002</threshold>
+            <left_val>-7.0504772663116455e-001</left_val>
+            <right_val>8.9823968708515167e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 6 -1.</_>
+                <_>
+                  11 3 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9676232263445854e-003</threshold>
+            <left_val>-2.0258559286594391e-001</left_val>
+            <right_val>2.4594809859991074e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 6 1 -1.</_>
+                <_>
+                  6 12 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.9255158305168152e-002</threshold>
+            <left_val>7.7862018346786499e-001</left_val>
+            <right_val>-8.2329802215099335e-002</right_val></_></_></trees>
+      <stage_threshold>-1.3562519550323486e+000</stage_threshold>
+      <parent>8</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 10 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 3 -1.</_>
+                <_>
+                  3 13 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2280860245227814e-002</threshold>
+            <left_val>-4.3323940038681030e-001</left_val>
+            <right_val>3.1084230542182922e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 8 2 -1.</_>
+                <_>
+                  6 6 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.2466039061546326e-002</threshold>
+            <left_val>-2.5457349419593811e-001</left_val>
+            <right_val>2.8453230857849121e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 4 2 -1.</_>
+                <_>
+                  4 2 2 1 2.</_>
+                <_>
+                  6 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9204079657793045e-003</threshold>
+            <left_val>-2.4197019636631012e-001</left_val>
+            <right_val>3.8850378990173340e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 6 -1.</_>
+                <_>
+                  10 3 2 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4881529845297337e-002</threshold>
+            <left_val>-2.0224849879741669e-001</left_val>
+            <right_val>2.0803029835224152e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 4 4 -1.</_>
+                <_>
+                  0 4 2 2 2.</_>
+                <_>
+                  2 6 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.8258059541694820e-004</threshold>
+            <left_val>2.0644129812717438e-001</left_val>
+            <right_val>-4.6135428547859192e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 6 -1.</_>
+                <_>
+                  10 3 2 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0871110111474991e-001</threshold>
+            <left_val>-1.1968149803578854e-002</left_val>
+            <right_val>-8.3505737781524658e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 6 -1.</_>
+                <_>
+                  0 3 2 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1553530202945694e-004</threshold>
+            <left_val>-6.2181282043457031e-001</left_val>
+            <right_val>1.2894719839096069e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 18 1 2 -1.</_>
+                <_>
+                  11 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9984820391982794e-003</threshold>
+            <left_val>1.2071420252323151e-001</left_val>
+            <right_val>-5.1865231990814209e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 1 2 -1.</_>
+                <_>
+                  0 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9442409393377602e-004</threshold>
+            <left_val>1.5316960215568542e-001</left_val>
+            <right_val>-4.6682178974151611e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  6 13 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.4691508859395981e-002</threshold>
+            <left_val>5.2325479686260223e-002</left_val>
+            <right_val>-5.6493771076202393e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 3 -1.</_>
+                <_>
+                  6 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2708869576454163e-001</threshold>
+            <left_val>-1.1623410135507584e-001</left_val>
+            <right_val>6.6390967369079590e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 6 -1.</_>
+                <_>
+                  0 13 6 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8425850570201874e-001</threshold>
+            <left_val>-2.9410699009895325e-001</left_val>
+            <right_val>2.7760609984397888e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 8 4 -1.</_>
+                <_>
+                  0 5 4 2 2.</_>
+                <_>
+                  4 7 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0079169645905495e-002</threshold>
+            <left_val>2.0110170543193817e-001</left_val>
+            <right_val>-3.7747490406036377e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 3 -1.</_>
+                <_>
+                  1 1 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3211309686303139e-002</threshold>
+            <left_val>-1.5770949423313141e-001</left_val>
+            <right_val>4.1628879308700562e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 12 6 -1.</_>
+                <_>
+                  0 5 12 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.5837738588452339e-003</threshold>
+            <left_val>-6.4297300577163696e-001</left_val>
+            <right_val>9.1064400970935822e-002</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 5 18 -1.</_>
+                <_>
+                  5 6 5 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0105128884315491e-001</threshold>
+            <left_val>1.8554370850324631e-002</left_val>
+            <right_val>-3.6014398932456970e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 9 9 -1.</_>
+                <_>
+                  3 0 3 9 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5468631908297539e-003</threshold>
+            <left_val>1.1459550261497498e-001</left_val>
+            <right_val>-5.0818997621536255e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 6 1 3 -1.</_>
+                <_>
+                  11 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.2614849042147398e-003</threshold>
+            <left_val>-6.5068858861923218e-001</left_val>
+            <right_val>7.1761913597583771e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 4 2 -1.</_>
+                <_>
+                  2 12 2 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.1482119336724281e-003</threshold>
+            <left_val>1.3169400393962860e-001</left_val>
+            <right_val>-3.7837469577789307e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 6 1 3 -1.</_>
+                <_>
+                  11 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2770840227603912e-003</threshold>
+            <left_val>4.9258850514888763e-002</left_val>
+            <right_val>-5.8316987752914429e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 10 3 1 -1.</_>
+                <_>
+                  2 10 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8884320054203272e-003</threshold>
+            <left_val>3.1445708870887756e-001</left_val>
+            <right_val>-1.6602359712123871e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 14 3 4 -1.</_>
+                <_>
+                  9 16 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.7958120703697205e-002</threshold>
+            <left_val>-7.2590202093124390e-001</left_val>
+            <right_val>1.5948530286550522e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 3 4 -1.</_>
+                <_>
+                  0 16 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6324709877371788e-002</threshold>
+            <left_val>7.4111200869083405e-002</left_val>
+            <right_val>-6.6733390092849731e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 3 -1.</_>
+                <_>
+                  8 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3688339851796627e-002</threshold>
+            <left_val>4.7244258224964142e-002</left_val>
+            <right_val>-3.2059279084205627e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 3 -1.</_>
+                <_>
+                  4 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5577600337564945e-002</threshold>
+            <left_val>-9.6644677221775055e-002</left_val>
+            <right_val>5.0794398784637451e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 6 1 3 -1.</_>
+                <_>
+                  11 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.4227044135332108e-003</threshold>
+            <left_val>-9.9238747358322144e-001</left_val>
+            <right_val>2.0270830020308495e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 1 3 -1.</_>
+                <_>
+                  0 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.8861939683556557e-003</threshold>
+            <left_val>7.3856048285961151e-002</left_val>
+            <right_val>-6.7188322544097900e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 6 8 -1.</_>
+                <_>
+                  3 10 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.3598121255636215e-002</threshold>
+            <left_val>-7.3445242643356323e-001</left_val>
+            <right_val>5.7080879807472229e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  5 5 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7251629382371902e-002</threshold>
+            <left_val>-1.3607659935951233e-001</left_val>
+            <right_val>4.2951139807701111e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 3 4 -1.</_>
+                <_>
+                  9 6 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.1715810298919678e-002</threshold>
+            <left_val>-7.4400889873504639e-001</left_val>
+            <right_val>3.3651608973741531e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 4 3 -1.</_>
+                <_>
+                  3 6 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0187040083110332e-002</threshold>
+            <left_val>-1.6512380540370941e-001</left_val>
+            <right_val>3.5162070393562317e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 3 1 -1.</_>
+                <_>
+                  8 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.7060850299894810e-003</threshold>
+            <left_val>6.8452596664428711e-002</left_val>
+            <right_val>-1.8737269937992096e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 2 3 -1.</_>
+                <_>
+                  2 1 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.5564024522900581e-003</threshold>
+            <left_val>-5.8053100109100342e-001</left_val>
+            <right_val>8.2600042223930359e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4073489606380463e-001</threshold>
+            <left_val>-1.</left_val>
+            <right_val>-6.1561721377074718e-003</right_val></_></_></trees>
+      <stage_threshold>-1.4609309434890747e+000</stage_threshold>
+      <parent>9</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 11 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 2 4 -1.</_>
+                <_>
+                  5 5 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.2872863858938217e-003</threshold>
+            <left_val>-3.3240118622779846e-001</left_val>
+            <right_val>4.0866941213607788e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 14 6 6 -1.</_>
+                <_>
+                  3 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.3943969309329987e-002</threshold>
+            <left_val>2.7990311384201050e-001</left_val>
+            <right_val>-3.5782578587532043e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 8 12 -1.</_>
+                <_>
+                  2 5 4 12 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1539819650352001e-002</threshold>
+            <left_val>2.1358589828014374e-001</left_val>
+            <right_val>-4.5100399851799011e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 4 -1.</_>
+                <_>
+                  11 0 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.5745559707283974e-002</threshold>
+            <left_val>2.1471889317035675e-001</left_val>
+            <right_val>-9.9175170063972473e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 4 1 -1.</_>
+                <_>
+                  1 0 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.3527829432860017e-003</threshold>
+            <left_val>1.5119549632072449e-001</left_val>
+            <right_val>-5.2674210071563721e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 18 6 2 -1.</_>
+                <_>
+                  7 18 3 1 2.</_>
+                <_>
+                  4 19 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1468210257589817e-002</threshold>
+            <left_val>1.3523469865322113e-001</left_val>
+            <right_val>-3.7286050617694855e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 8 2 -1.</_>
+                <_>
+                  0 18 4 1 2.</_>
+                <_>
+                  4 19 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5535906255245209e-003</threshold>
+            <left_val>-2.5730869174003601e-001</left_val>
+            <right_val>2.4693550169467926e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 8 8 -1.</_>
+                <_>
+                  6 0 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.6266319006681442e-002</threshold>
+            <left_val>-2.1571849286556244e-001</left_val>
+            <right_val>1.8734970688819885e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 1 -1.</_>
+                <_>
+                  1 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0349300466477871e-003</threshold>
+            <left_val>8.9395299553871155e-002</left_val>
+            <right_val>-6.2484967708587646e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 1 -1.</_>
+                <_>
+                  10 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0920839849859476e-003</threshold>
+            <left_val>-3.2366481423377991e-001</left_val>
+            <right_val>6.9054901599884033e-002</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  6 13 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.1597058773040771e-002</threshold>
+            <left_val>6.1383968591690063e-001</left_val>
+            <right_val>-9.5396347343921661e-002</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 1 -1.</_>
+                <_>
+                  3 13 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7433969303965569e-002</threshold>
+            <left_val>-2.5729641318321228e-001</left_val>
+            <right_val>2.5275719165802002e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 8 5 -1.</_>
+                <_>
+                  4 11 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.6819643378257751e-002</threshold>
+            <left_val>8.7492428719997406e-002</left_val>
+            <right_val>-6.7382502555847168e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 6 4 14 -1.</_>
+                <_>
+                  10 6 2 7 2.</_>
+                <_>
+                  8 13 2 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.0648958683013916e-002</threshold>
+            <left_val>-5.7000648230314255e-002</left_val>
+            <right_val>4.2771929502487183e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 4 14 -1.</_>
+                <_>
+                  0 6 2 7 2.</_>
+                <_>
+                  2 13 2 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.0360638201236725e-003</threshold>
+            <left_val>-4.2870849370956421e-001</left_val>
+            <right_val>1.4574399590492249e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 3 8 2 -1.</_>
+                <_>
+                  4 4 8 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.9487157957628369e-004</threshold>
+            <left_val>-4.4867759943008423e-001</left_val>
+            <right_val>8.7952293455600739e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 1 -1.</_>
+                <_>
+                  1 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0319919567555189e-003</threshold>
+            <left_val>-6.9378471374511719e-001</left_val>
+            <right_val>7.9090960323810577e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 3 -1.</_>
+                <_>
+                  1 1 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5986919403076172e-002</threshold>
+            <left_val>-1.8177279829978943e-001</left_val>
+            <right_val>3.3544349670410156e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 3 2 -1.</_>
+                <_>
+                  1 18 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0031439887825400e-004</threshold>
+            <left_val>-2.8036159276962280e-001</left_val>
+            <right_val>1.8939669430255890e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 12 12 -1.</_>
+                <_>
+                  0 8 12 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0664870738983154e-001</threshold>
+            <left_val>-7.0004421472549438e-001</left_val>
+            <right_val>6.2915571033954620e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 6 14 -1.</_>
+                <_>
+                  0 13 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0939550120383501e-003</threshold>
+            <left_val>-5.6122779846191406e-001</left_val>
+            <right_val>7.9117156565189362e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 3 1 -1.</_>
+                <_>
+                  9 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0714650154113770e-002</threshold>
+            <left_val>3.6672711372375488e-002</left_val>
+            <right_val>-4.8171210289001465e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 7 2 3 -1.</_>
+                <_>
+                  4 8 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2993469834327698e-002</threshold>
+            <left_val>-1.3089600205421448e-001</left_val>
+            <right_val>3.2844379544258118e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 3 1 3 -1.</_>
+                <_>
+                  11 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4268362000584602e-003</threshold>
+            <left_val>4.6886149793863297e-002</left_val>
+            <right_val>-5.8115488290786743e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 1 3 2 -1.</_>
+                <_>
+                  2 1 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0718739591538906e-002</threshold>
+            <left_val>5.9297699481248856e-002</left_val>
+            <right_val>-6.6856807470321655e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 3 1 3 -1.</_>
+                <_>
+                  11 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1285220757126808e-003</threshold>
+            <left_val>-3.5857740044593811e-001</left_val>
+            <right_val>2.8134709224104881e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 17 1 2 -1.</_>
+                <_>
+                  3 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.2357040112838149e-004</threshold>
+            <left_val>-3.4198528528213501e-001</left_val>
+            <right_val>1.2199939787387848e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 3 1 3 -1.</_>
+                <_>
+                  11 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0644399560987949e-002</threshold>
+            <left_val>3.9803087711334229e-003</left_val>
+            <right_val>-6.9705927371978760e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 2 3 -1.</_>
+                <_>
+                  5 7 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5901770442724228e-002</threshold>
+            <left_val>-7.6809287071228027e-002</left_val>
+            <right_val>5.2953928709030151e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 3 1 3 -1.</_>
+                <_>
+                  11 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0395360179245472e-002</threshold>
+            <left_val>-6.4491081237792969e-001</left_val>
+            <right_val>1.0781600140035152e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 1 3 -1.</_>
+                <_>
+                  0 4 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7131321150809526e-003</threshold>
+            <left_val>6.6979996860027313e-002</left_val>
+            <right_val>-6.2111258506774902e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 2 -1.</_>
+                <_>
+                  7 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.3174570873379707e-002</threshold>
+            <left_val>1.6732679679989815e-002</left_val>
+            <right_val>-4.5888119935989380e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 2 3 -1.</_>
+                <_>
+                  5 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1146579869091511e-002</threshold>
+            <left_val>-1.1638499796390533e-001</left_val>
+            <right_val>4.3002909421920776e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 8 1 4 -1.</_>
+                <_>
+                  11 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2715480290353298e-002</threshold>
+            <left_val>1.6517929732799530e-002</left_val>
+            <right_val>-6.6795057058334351e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 2 4 6 -1.</_>
+                <_>
+                  4 4 4 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2653400190174580e-002</threshold>
+            <left_val>1.1365109682083130e-001</left_val>
+            <right_val>-3.7035998702049255e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 17 6 2 -1.</_>
+                <_>
+                  8 17 3 1 2.</_>
+                <_>
+                  5 18 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.1139880456030369e-003</threshold>
+            <left_val>1.7468209564685822e-001</left_val>
+            <right_val>-1.2769439816474915e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 2 -1.</_>
+                <_>
+                  3 0 3 1 2.</_>
+                <_>
+                  6 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3703290373086929e-002</threshold>
+            <left_val>4.2330458760261536e-001</left_val>
+            <right_val>-9.5448397099971771e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 3 1 2 -1.</_>
+                <_>
+                  11 4 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5888428837060928e-003</threshold>
+            <left_val>-8.7192570790648460e-003</left_val>
+            <right_val>3.0307659506797791e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 1 2 -1.</_>
+                <_>
+                  0 4 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.7711452245712280e-004</threshold>
+            <left_val>-5.0375598669052124e-001</left_val>
+            <right_val>9.0188682079315186e-002</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 4 -1.</_>
+                <_>
+                  10 5 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.1391671188175678e-003</threshold>
+            <left_val>-6.0663592815399170e-001</left_val>
+            <right_val>4.6589769423007965e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 1 4 -1.</_>
+                <_>
+                  0 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.4300412456505001e-005</threshold>
+            <left_val>-2.6559790968894958e-001</left_val>
+            <right_val>1.5030109882354736e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 5 -1.</_>
+                <_>
+                  0 13 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4399429559707642e-001</threshold>
+            <left_val>6.4060389995574951e-001</left_val>
+            <right_val>-6.8897739052772522e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 10 10 -1.</_>
+                <_>
+                  1 9 5 5 2.</_>
+                <_>
+                  6 14 5 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.2823240458965302e-001</threshold>
+            <left_val>2.1190899610519409e-001</left_val>
+            <right_val>-2.7341139316558838e-001</right_val></_></_></trees>
+      <stage_threshold>-1.4843599796295166e+000</stage_threshold>
+      <parent>10</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 12 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 1 6 2 -1.</_>
+                <_>
+                  1 1 3 1 2.</_>
+                <_>
+                  4 2 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.8697589710354805e-003</threshold>
+            <left_val>4.8807978630065918e-001</left_val>
+            <right_val>-2.6589471101760864e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 4 3 5 -1.</_>
+                <_>
+                  8 5 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.3131919801235199e-002</threshold>
+            <left_val>3.2597500830888748e-002</left_val>
+            <right_val>-6.3295251131057739e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 1 -1.</_>
+                <_>
+                  8 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7511799931526184e-002</threshold>
+            <left_val>-3.5473251342773438e-001</left_val>
+            <right_val>2.8011149168014526e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 4 1 12 -1.</_>
+                <_>
+                  11 8 1 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.3885500431060791e-002</threshold>
+            <left_val>4.7378170490264893e-001</left_val>
+            <right_val>-1.1292530223727226e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 1 12 -1.</_>
+                <_>
+                  0 8 1 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8212760332971811e-003</threshold>
+            <left_val>-4.6179610490798950e-001</left_val>
+            <right_val>1.4266149699687958e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 4 8 -1.</_>
+                <_>
+                  6 10 4 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.5360601544380188e-002</threshold>
+            <left_val>-6.6754668951034546e-001</left_val>
+            <right_val>7.5132578611373901e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 10 12 -1.</_>
+                <_>
+                  1 7 5 6 2.</_>
+                <_>
+                  6 13 5 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7539798617362976e-001</threshold>
+            <left_val>3.8147959113121033e-001</left_val>
+            <right_val>-2.3665140569210052e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.0699970200657845e-002</threshold>
+            <left_val>5.1691979169845581e-002</left_val>
+            <right_val>-2.4286730587482452e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 4 4 -1.</_>
+                <_>
+                  3 6 2 2 2.</_>
+                <_>
+                  5 8 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.6332989633083344e-003</threshold>
+            <left_val>3.3072310686111450e-001</left_val>
+            <right_val>-2.0818190276622772e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 2 2 2 -1.</_>
+                <_>
+                  10 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6330240294337273e-002</threshold>
+            <left_val>3.4118140320060775e-005</left_val>
+            <right_val>-8.0960237979888916e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 2 2 -1.</_>
+                <_>
+                  0 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.6133222794160247e-005</threshold>
+            <left_val>-3.7730661034584045e-001</left_val>
+            <right_val>1.3947279751300812e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 17 2 1 -1.</_>
+                <_>
+                  8 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.0760519206523895e-002</threshold>
+            <left_val>6.7611587047576904e-001</left_val>
+            <right_val>-1.4665770344436169e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 3 3 -1.</_>
+                <_>
+                  1 8 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.8717780523002148e-003</threshold>
+            <left_val>-1.6677060723304749e-001</left_val>
+            <right_val>3.0840030312538147e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 14 3 6 -1.</_>
+                <_>
+                  6 14 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7696250230073929e-002</threshold>
+            <left_val>3.8468770682811737e-002</left_val>
+            <right_val>-5.9128028154373169e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 3 5 -1.</_>
+                <_>
+                  5 14 1 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4457659795880318e-002</threshold>
+            <left_val>7.1180373430252075e-002</left_val>
+            <right_val>-6.8788748979568481e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 2 -1.</_>
+                <_>
+                  10 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.4003669172525406e-003</threshold>
+            <left_val>-1.7107939720153809e-001</left_val>
+            <right_val>3.3334150910377502e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 2 -1.</_>
+                <_>
+                  0 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9785019103437662e-003</threshold>
+            <left_val>-6.3402158021926880e-001</left_val>
+            <right_val>8.5248172283172607e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 12 7 -1.</_>
+                <_>
+                  0 12 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.5506778955459595e-001</threshold>
+            <left_val>6.9163411855697632e-001</left_val>
+            <right_val>-8.7763786315917969e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 14 3 2 -1.</_>
+                <_>
+                  7 15 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2596770189702511e-002</threshold>
+            <left_val>-2.0116379857063293e-001</left_val>
+            <right_val>3.4040948748588562e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 16 1 4 -1.</_>
+                <_>
+                  11 18 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3926040157675743e-003</threshold>
+            <left_val>-6.2525659799575806e-001</left_val>
+            <right_val>1.1060170084238052e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 1 4 -1.</_>
+                <_>
+                  0 18 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.7672837253194302e-005</threshold>
+            <left_val>1.4002850651741028e-001</left_val>
+            <right_val>-3.9103108644485474e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 6 4 -1.</_>
+                <_>
+                  4 4 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4524061270058155e-003</threshold>
+            <left_val>-3.1052809953689575e-001</left_val>
+            <right_val>6.3757672905921936e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 6 3 3 -1.</_>
+                <_>
+                  4 7 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2568219564855099e-002</threshold>
+            <left_val>-1.3675519824028015e-001</left_val>
+            <right_val>3.2680550217628479e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 20 -1.</_>
+                <_>
+                  8 10 4 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7843358516693115e-001</threshold>
+            <left_val>-3.7364691495895386e-002</left_val>
+            <right_val>3.7789309024810791e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 11 2 3 -1.</_>
+                <_>
+                  3 12 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.3601790200918913e-003</threshold>
+            <left_val>2.9605069756507874e-001</left_val>
+            <right_val>-1.5206739306449890e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 4 20 -1.</_>
+                <_>
+                  8 10 4 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3185380101203918e-001</threshold>
+            <left_val>-6.8029761314392090e-001</left_val>
+            <right_val>1.2745309621095657e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 20 -1.</_>
+                <_>
+                  0 10 4 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.3479618877172470e-003</threshold>
+            <left_val>-6.6707527637481689e-001</left_val>
+            <right_val>6.7926846444606781e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 3 -1.</_>
+                <_>
+                  6 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.5943907722830772e-003</threshold>
+            <left_val>-1.1112800240516663e-001</left_val>
+            <right_val>2.2462299466133118e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 3 -1.</_>
+                <_>
+                  6 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.3589297244325280e-005</threshold>
+            <left_val>1.3988719880580902e-001</left_val>
+            <right_val>-3.4220328927040100e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 3 1 -1.</_>
+                <_>
+                  8 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0304169700248167e-004</threshold>
+            <left_val>8.2018472254276276e-002</left_val>
+            <right_val>-1.0476870089769363e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 1 3 -1.</_>
+                <_>
+                  4 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.4624290205538273e-003</threshold>
+            <left_val>-5.1264250278472900e-001</left_val>
+            <right_val>9.2095062136650085e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 3 -1.</_>
+                <_>
+                  0 10 12 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9663229584693909e-002</threshold>
+            <left_val>6.1935991048812866e-002</left_val>
+            <right_val>-6.1648821830749512e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 8 1 -1.</_>
+                <_>
+                  2 0 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1055600043619052e-004</threshold>
+            <left_val>1.4308770000934601e-001</left_val>
+            <right_val>-2.7447059750556946e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 4 2 -1.</_>
+                <_>
+                  9 13 2 1 2.</_>
+                <_>
+                  7 14 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.8737419527024031e-003</threshold>
+            <left_val>-1.0690200328826904e-001</left_val>
+            <right_val>2.0657220482826233e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 13 4 2 -1.</_>
+                <_>
+                  1 13 2 1 2.</_>
+                <_>
+                  3 14 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5131230726838112e-003</threshold>
+            <left_val>3.4341660141944885e-001</left_val>
+            <right_val>-1.2317349761724472e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.1594668775796890e-002</threshold>
+            <left_val>9.3623742461204529e-002</left_val>
+            <right_val>-4.5765519142150879e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 2 1 -1.</_>
+                <_>
+                  3 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2142979539930820e-003</threshold>
+            <left_val>-1.3058850169181824e-001</left_val>
+            <right_val>3.0691918730735779e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3168719410896301e-001</threshold>
+            <left_val>1.1348670348525047e-002</left_val>
+            <right_val>-3.6062520742416382e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.8962578922510147e-003</threshold>
+            <left_val>9.7268536686897278e-002</left_val>
+            <right_val>-4.5470228791236877e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 6 2 3 -1.</_>
+                <_>
+                  10 7 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.3822340667247772e-003</threshold>
+            <left_val>-6.9014567136764526e-001</left_val>
+            <right_val>7.1008093655109406e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 4 3 -1.</_>
+                <_>
+                  5 4 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4433590471744537e-002</threshold>
+            <left_val>5.0112801790237427e-001</left_val>
+            <right_val>-9.8408728837966919e-002</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 3 1 -1.</_>
+                <_>
+                  8 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.6958734318614006e-003</threshold>
+            <left_val>-1.4006440341472626e-001</left_val>
+            <right_val>3.6845669150352478e-002</right_val></_></_></trees>
+      <stage_threshold>-1.4225620031356812e+000</stage_threshold>
+      <parent>11</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 13 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 1 3 -1.</_>
+                <_>
+                  5 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7152750864624977e-002</threshold>
+            <left_val>4.7029718756675720e-001</left_val>
+            <right_val>-2.2067089378833771e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 8 -1.</_>
+                <_>
+                  6 11 3 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.3040937781333923e-002</threshold>
+            <left_val>5.5113639682531357e-002</left_val>
+            <right_val>-5.5488407611846924e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 9 8 3 -1.</_>
+                <_>
+                  6 11 4 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2245059758424759e-001</threshold>
+            <left_val>-2.8312590718269348e-001</left_val>
+            <right_val>3.4973090887069702e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 1 3 -1.</_>
+                <_>
+                  6 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.3496531695127487e-003</threshold>
+            <left_val>-1.3282130658626556e-001</left_val>
+            <right_val>4.8876601457595825e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 2 -1.</_>
+                <_>
+                  4 0 2 1 2.</_>
+                <_>
+                  6 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.3082878738641739e-003</threshold>
+            <left_val>4.5475938916206360e-001</left_val>
+            <right_val>-1.4194749295711517e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 12 2 -1.</_>
+                <_>
+                  0 11 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7290420830249786e-002</threshold>
+            <left_val>9.8470740020275116e-002</left_val>
+            <right_val>-6.8155962228775024e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 8 5 -1.</_>
+                <_>
+                  4 11 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.8027682602405548e-002</threshold>
+            <left_val>1.2287759780883789e-001</left_val>
+            <right_val>-5.8085542917251587e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 4 2 -1.</_>
+                <_>
+                  7 0 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.5710109621286392e-003</threshold>
+            <left_val>-2.8932929039001465e-001</left_val>
+            <right_val>9.2327423393726349e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 2 7 8 -1.</_>
+                <_>
+                  2 4 7 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7197790332138538e-003</threshold>
+            <left_val>-4.8277780413627625e-001</left_val>
+            <right_val>1.2942260503768921e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 4 2 -1.</_>
+                <_>
+                  7 0 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.6168839782476425e-002</threshold>
+            <left_val>-3.3225961029529572e-002</left_val>
+            <right_val>2.8994488716125488e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 4 2 -1.</_>
+                <_>
+                  3 0 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5704417861998081e-003</threshold>
+            <left_val>-5.9805792570114136e-001</left_val>
+            <right_val>1.0446850210428238e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 17 3 3 -1.</_>
+                <_>
+                  9 18 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.7568379193544388e-003</threshold>
+            <left_val>1.2488850206136703e-001</left_val>
+            <right_val>-5.7084852457046509e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 3 3 -1.</_>
+                <_>
+                  0 18 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0054030939936638e-003</threshold>
+            <left_val>-3.2693040370941162e-001</left_val>
+            <right_val>1.9752669334411621e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0322710126638412e-001</threshold>
+            <left_val>5.9689277410507202e-001</left_val>
+            <right_val>-9.9626749753952026e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 12 5 -1.</_>
+                <_>
+                  3 11 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5584551095962524e-002</threshold>
+            <left_val>-2.3595149815082550e-001</left_val>
+            <right_val>2.7769410610198975e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 7 4 1 -1.</_>
+                <_>
+                  8 7 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7628820613026619e-002</threshold>
+            <left_val>2.3300230503082275e-001</left_val>
+            <right_val>-3.8094460964202881e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 7 1 4 -1.</_>
+                <_>
+                  4 7 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.3259319178760052e-003</threshold>
+            <left_val>1.5533800423145294e-001</left_val>
+            <right_val>-3.4289830923080444e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 6 7 -1.</_>
+                <_>
+                  6 0 2 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6643910109996796e-001</threshold>
+            <left_val>1.3593060430139303e-004</left_val>
+            <right_val>-6.0628050565719604e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 6 7 -1.</_>
+                <_>
+                  4 0 2 7 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3041920028626919e-002</threshold>
+            <left_val>1.0876829922199249e-001</left_val>
+            <right_val>-4.7265630960464478e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 16 12 3 -1.</_>
+                <_>
+                  0 17 12 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3597619719803333e-002</threshold>
+            <left_val>-5.8280581235885620e-001</left_val>
+            <right_val>7.2698637843132019e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 17 4 2 -1.</_>
+                <_>
+                  4 17 2 1 2.</_>
+                <_>
+                  6 18 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.8220919929444790e-003</threshold>
+            <left_val>-1.4359709620475769e-001</left_val>
+            <right_val>3.4434759616851807e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 1 -1.</_>
+                <_>
+                  10 0 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3025919906795025e-004</threshold>
+            <left_val>7.5394742190837860e-002</left_val>
+            <right_val>-6.7537508904933929e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 1 -1.</_>
+                <_>
+                  1 0 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4602119810879230e-003</threshold>
+            <left_val>-5.1882988214492798e-001</left_val>
+            <right_val>8.0956049263477325e-002</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 2 -1.</_>
+                <_>
+                  7 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.2538071274757385e-002</threshold>
+            <left_val>-5.8500260114669800e-001</left_val>
+            <right_val>5.7338178157806396e-003</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 3 1 -1.</_>
+                <_>
+                  4 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0106420852243900e-003</threshold>
+            <left_val>-1.0640989989042282e-001</left_val>
+            <right_val>4.0276700258255005e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 2 3 7 -1.</_>
+                <_>
+                  10 3 1 7 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.6432539820671082e-002</threshold>
+            <left_val>-4.2023709416389465e-001</left_val>
+            <right_val>4.2063061147928238e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 2 2 -1.</_>
+                <_>
+                  5 5 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.2824350036680698e-002</threshold>
+            <left_val>4.8449409008026123e-001</left_val>
+            <right_val>-9.4362497329711914e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 4 -1.</_>
+                <_>
+                  8 6 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.4120719879865646e-002</threshold>
+            <left_val>2.7428179979324341e-002</left_val>
+            <right_val>-5.6730318069458008e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 4 3 -1.</_>
+                <_>
+                  4 6 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.4012650847434998e-002</threshold>
+            <left_val>3.7047350406646729e-001</left_val>
+            <right_val>-1.3064679503440857e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 2 -1.</_>
+                <_>
+                  10 5 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.7362610455602407e-003</threshold>
+            <left_val>-6.1717242002487183e-001</left_val>
+            <right_val>4.6860579401254654e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 2 3 -1.</_>
+                <_>
+                  0 4 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.2141821943223476e-003</threshold>
+            <left_val>-6.5322470664978027e-001</left_val>
+            <right_val>5.3996030241250992e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 2 -1.</_>
+                <_>
+                  10 5 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.4924731850624084e-003</threshold>
+            <left_val>4.4800970703363419e-002</left_val>
+            <right_val>-4.3987420201301575e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 2 2 -1.</_>
+                <_>
+                  0 5 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.2384970001876354e-003</threshold>
+            <left_val>-7.1687930822372437e-001</left_val>
+            <right_val>5.4430369287729263e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 10 2 1 -1.</_>
+                <_>
+                  7 10 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1804300379008055e-003</threshold>
+            <left_val>2.4815900623798370e-001</left_val>
+            <right_val>-8.9008152484893799e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 10 2 1 -1.</_>
+                <_>
+                  4 10 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9277798603288829e-004</threshold>
+            <left_val>-2.1440739929676056e-001</left_val>
+            <right_val>2.0239150524139404e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 2 -1.</_>
+                <_>
+                  5 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1838439851999283e-002</threshold>
+            <left_val>6.8225288391113281e-001</left_val>
+            <right_val>-5.6109890341758728e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 14 4 2 -1.</_>
+                <_>
+                  5 14 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0604960620403290e-002</threshold>
+            <left_val>-6.4495718479156494e-001</left_val>
+            <right_val>6.5811157226562500e-002</right_val></_></_></trees>
+      <stage_threshold>-1.3051190376281738e+000</stage_threshold>
+      <parent>12</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 14 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 3 3 -1.</_>
+                <_>
+                  4 7 3 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.7252319529652596e-003</threshold>
+            <left_val>3.4108111262321472e-001</left_val>
+            <right_val>-3.3441230654716492e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 5 6 14 -1.</_>
+                <_>
+                  6 5 3 7 2.</_>
+                <_>
+                  3 12 3 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5814049541950226e-001</threshold>
+            <left_val>-2.9555070400238037e-001</left_val>
+            <right_val>2.9280221462249756e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 3 2 -1.</_>
+                <_>
+                  3 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5558689851313829e-003</threshold>
+            <left_val>-2.8485581278800964e-001</left_val>
+            <right_val>2.4933080375194550e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 18 5 2 -1.</_>
+                <_>
+                  7 19 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1524680089205503e-003</threshold>
+            <left_val>-4.6672669053077698e-001</left_val>
+            <right_val>7.6127722859382629e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 10 2 -1.</_>
+                <_>
+                  0 19 10 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4493550173938274e-002</threshold>
+            <left_val>2.5777289271354675e-001</left_val>
+            <right_val>-2.4369129538536072e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 2 1 15 -1.</_>
+                <_>
+                  11 7 1 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.8386606872081757e-002</threshold>
+            <left_val>5.2669358253479004e-001</left_val>
+            <right_val>8.9219277724623680e-003</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 1 6 -1.</_>
+                <_>
+                  0 7 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0660409461706877e-003</threshold>
+            <left_val>-4.9784231185913086e-001</left_val>
+            <right_val>1.1696430295705795e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 9 8 -1.</_>
+                <_>
+                  3 4 9 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6208799555897713e-002</threshold>
+            <left_val>-3.0983239412307739e-001</left_val>
+            <right_val>9.5886580646038055e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 15 12 5 -1.</_>
+                <_>
+                  6 15 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.8249868750572205e-001</threshold>
+            <left_val>-7.3715627193450928e-002</left_val>
+            <right_val>6.4200782775878906e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 3 6 -1.</_>
+                <_>
+                  4 11 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.6361259222030640e-002</threshold>
+            <left_val>4.0710549801588058e-002</left_val>
+            <right_val>-5.0559818744659424e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 9 6 3 -1.</_>
+                <_>
+                  8 11 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.1451180130243301e-002</threshold>
+            <left_val>-3.3384099602699280e-001</left_val>
+            <right_val>1.6614030301570892e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 10 2 -1.</_>
+                <_>
+                  2 0 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.9037936627864838e-002</threshold>
+            <left_val>-3.1987860798835754e-001</left_val>
+            <right_val>3.4255299717187881e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 10 2 -1.</_>
+                <_>
+                  5 0 5 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.6569739244878292e-003</threshold>
+            <left_val>-6.1266559362411499e-001</left_val>
+            <right_val>8.3148159086704254e-002</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.1886749938130379e-003</threshold>
+            <left_val>4.2386818677186966e-002</left_val>
+            <right_val>-9.7789242863655090e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  4 5 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.6780599728226662e-002</threshold>
+            <left_val>1.2735369801521301e-001</left_val>
+            <right_val>-3.4852239489555359e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 6 5 -1.</_>
+                <_>
+                  6 0 3 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.9346590898931026e-003</threshold>
+            <left_val>4.4443860650062561e-002</left_val>
+            <right_val>-2.6666578650474548e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 5 6 -1.</_>
+                <_>
+                  6 0 5 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2057109922170639e-001</threshold>
+            <left_val>9.1515138745307922e-002</left_val>
+            <right_val>-5.5102181434631348e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0571300052106380e-002</threshold>
+            <left_val>-1.1927139759063721e-001</left_val>
+            <right_val>1.5043540298938751e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 2 3 -1.</_>
+                <_>
+                  3 9 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.4446419663727283e-002</threshold>
+            <left_val>3.2619118690490723e-001</left_val>
+            <right_val>-1.3021939992904663e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 6 1 3 -1.</_>
+                <_>
+                  11 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.9188970588147640e-003</threshold>
+            <left_val>2.4317760020494461e-002</left_val>
+            <right_val>-5.8825939893722534e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 6 1 3 -1.</_>
+                <_>
+                  0 7 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.8240209687501192e-003</threshold>
+            <left_val>-6.5660482645034790e-001</left_val>
+            <right_val>6.3337683677673340e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 12 8 -1.</_>
+                <_>
+                  0 15 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7404669523239136e-001</threshold>
+            <left_val>-5.4772597551345825e-001</left_val>
+            <right_val>6.0019370168447495e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 13 6 3 -1.</_>
+                <_>
+                  5 13 2 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.5922618359327316e-002</threshold>
+            <left_val>5.0438169389963150e-002</left_val>
+            <right_val>-6.9467681646347046e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 16 2 4 -1.</_>
+                <_>
+                  5 17 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9035470690578222e-003</threshold>
+            <left_val>2.2018410265445709e-001</left_val>
+            <right_val>-1.8376649916172028e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 1 2 1 -1.</_>
+                <_>
+                  1 1 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7436769558116794e-003</threshold>
+            <left_val>6.1212658882141113e-002</left_val>
+            <right_val>-5.7988357543945313e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 15 2 3 -1.</_>
+                <_>
+                  5 16 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.7301546484231949e-003</threshold>
+            <left_val>-5.1599711179733276e-001</left_val>
+            <right_val>4.9021121114492416e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 3 -1.</_>
+                <_>
+                  4 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.0866428762674332e-002</threshold>
+            <left_val>4.3118700385093689e-001</left_val>
+            <right_val>-9.5599338412284851e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 3 -1.</_>
+                <_>
+                  6 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5334750059992075e-004</threshold>
+            <left_val>-8.4842063486576080e-002</left_val>
+            <right_val>5.3982339799404144e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 2 3 -1.</_>
+                <_>
+                  4 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.9509448260068893e-003</threshold>
+            <left_val>4.7792288661003113e-001</left_val>
+            <right_val>-9.3340940773487091e-002</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 5 2 3 -1.</_>
+                <_>
+                  10 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4662738218903542e-003</threshold>
+            <left_val>-6.6406428813934326e-001</left_val>
+            <right_val>7.0635370910167694e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 2 3 -1.</_>
+                <_>
+                  5 6 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.7459428682923317e-003</threshold>
+            <left_val>-9.5945097506046295e-002</left_val>
+            <right_val>4.5204031467437744e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 7 1 8 -1.</_>
+                <_>
+                  6 9 1 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.8576910048723221e-002</threshold>
+            <left_val>-2.5402069091796875e-001</left_val>
+            <right_val>3.5480510443449020e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 2 3 -1.</_>
+                <_>
+                  0 6 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.1895291805267334e-003</threshold>
+            <left_val>-6.9631862640380859e-001</left_val>
+            <right_val>5.4189778864383698e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 2 3 -1.</_>
+                <_>
+                  5 5 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3830559328198433e-004</threshold>
+            <left_val>7.7265933156013489e-002</left_val>
+            <right_val>-4.3882951140403748e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 7 8 1 -1.</_>
+                <_>
+                  6 9 4 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.9827160760760307e-002</threshold>
+            <left_val>5.1934647560119629e-001</left_val>
+            <right_val>-7.4816159904003143e-002</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 15 2 3 -1.</_>
+                <_>
+                  5 16 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9728230312466621e-002</threshold>
+            <left_val>4.6895399689674377e-002</left_val>
+            <right_val>-5.6989020109176636e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 15 3 2 -1.</_>
+                <_>
+                  7 16 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2107780203223228e-002</threshold>
+            <left_val>-1.3739739358425140e-001</left_val>
+            <right_val>3.2666760683059692e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 13 2 3 -1.</_>
+                <_>
+                  9 14 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.9206808693706989e-003</threshold>
+            <left_val>4.6539328992366791e-002</left_val>
+            <right_val>-4.9861478805541992e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 13 2 3 -1.</_>
+                <_>
+                  1 14 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5631309300661087e-003</threshold>
+            <left_val>-1.0235120356082916e-001</left_val>
+            <right_val>3.9567971229553223e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 12 12 -1.</_>
+                <_>
+                  0 9 12 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3844289779663086e-001</threshold>
+            <left_val>-7.1881687641143799e-001</left_val>
+            <right_val>4.9742348492145538e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 3 2 -1.</_>
+                <_>
+                  1 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.2327659949660301e-003</threshold>
+            <left_val>4.8625311255455017e-001</left_val>
+            <right_val>-7.8327029943466187e-002</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  8 15 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2344529852271080e-002</threshold>
+            <left_val>-4.5567270368337631e-002</left_val>
+            <right_val>1.6513639688491821e-001</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 4 -1.</_>
+                <_>
+                  0 9 1 2 2.</_>
+                <_>
+                  1 11 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0889769764617085e-003</threshold>
+            <left_val>2.3016020655632019e-001</left_val>
+            <right_val>-1.4696329832077026e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 17 8 2 -1.</_>
+                <_>
+                  6 17 4 1 2.</_>
+                <_>
+                  2 18 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.1214238628745079e-003</threshold>
+            <left_val>1.7787009477615356e-001</left_val>
+            <right_val>-1.9967870414257050e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 9 2 -1.</_>
+                <_>
+                  1 9 9 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3381220176815987e-002</threshold>
+            <left_val>3.9966959506273270e-002</left_val>
+            <right_val>-7.6583552360534668e-001</right_val></_></_></trees>
+      <stage_threshold>-1.2928479909896851e+000</stage_threshold>
+      <parent>13</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 15 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 1 4 -1.</_>
+                <_>
+                  5 5 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.8875479735434055e-003</threshold>
+            <left_val>-2.6197949051856995e-001</left_val>
+            <right_val>3.9267268776893616e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 3 3 -1.</_>
+                <_>
+                  7 1 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0563710480928421e-002</threshold>
+            <left_val>2.3240800201892853e-001</left_val>
+            <right_val>-3.6058109253644943e-002</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 3 3 -1.</_>
+                <_>
+                  5 1 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4195060133934021e-002</threshold>
+            <left_val>-1.7246599495410919e-001</left_val>
+            <right_val>4.0554100275039673e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 6 -1.</_>
+                <_>
+                  0 13 6 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.2053229808807373e-001</threshold>
+            <left_val>-2.4937939643859863e-001</left_val>
+            <right_val>2.4980540573596954e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 3 3 -1.</_>
+                <_>
+                  6 5 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>8.1213507801294327e-003</threshold>
+            <left_val>9.8432846367359161e-002</left_val>
+            <right_val>-5.0667357444763184e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 17 1 3 -1.</_>
+                <_>
+                  9 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5637070173397660e-003</threshold>
+            <left_val>-4.1526609659194946e-001</left_val>
+            <right_val>1.3340100646018982e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 17 1 3 -1.</_>
+                <_>
+                  2 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2210609856992960e-003</threshold>
+            <left_val>-2.5663951039314270e-001</left_val>
+            <right_val>2.1268320083618164e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 6 -1.</_>
+                <_>
+                  0 11 12 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.5655488967895508e-002</threshold>
+            <left_val>8.5712976753711700e-002</left_val>
+            <right_val>-5.5701047182083130e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 6 6 2 -1.</_>
+                <_>
+                  5 6 3 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.7322370782494545e-002</threshold>
+            <left_val>1.0083419829607010e-001</left_val>
+            <right_val>-4.3052899837493896e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 4 -1.</_>
+                <_>
+                  7 5 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.7879169210791588e-002</threshold>
+            <left_val>4.4392268173396587e-003</left_val>
+            <right_val>-5.7203328609466553e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 4 3 -1.</_>
+                <_>
+                  5 5 4 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.7942388802766800e-002</threshold>
+            <left_val>4.9971351027488708e-001</left_val>
+            <right_val>-1.0569220036268234e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 4 1 16 -1.</_>
+                <_>
+                  11 8 1 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.0003162622451782e-002</threshold>
+            <left_val>7.7226841449737549e-001</left_val>
+            <right_val>-3.5037949681282043e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 20 -1.</_>
+                <_>
+                  0 5 1 10 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.1878979168832302e-003</threshold>
+            <left_val>-4.3980291485786438e-001</left_val>
+            <right_val>1.0962349921464920e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 2 1 -1.</_>
+                <_>
+                  9 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1160460300743580e-002</threshold>
+            <left_val>-6.0748499631881714e-001</left_val>
+            <right_val>2.5118330493569374e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 1 2 -1.</_>
+                <_>
+                  3 0 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.3293609265238047e-003</threshold>
+            <left_val>7.4755467474460602e-002</left_val>
+            <right_val>-5.6645327806472778e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 6 -1.</_>
+                <_>
+                  9 13 3 3 2.</_>
+                <_>
+                  6 16 3 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.2051369547843933e-002</threshold>
+            <left_val>1.3710969686508179e-001</left_val>
+            <right_val>-1.4014610648155212e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 4 -1.</_>
+                <_>
+                  8 12 2 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.0117290169000626e-001</threshold>
+            <left_val>6.2204962968826294e-001</left_val>
+            <right_val>-6.4412176609039307e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 3 -1.</_>
+                <_>
+                  1 1 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2040869593620300e-002</threshold>
+            <left_val>-8.5930466651916504e-002</left_val>
+            <right_val>4.9315661191940308e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 6 6 -1.</_>
+                <_>
+                  0 13 3 3 2.</_>
+                <_>
+                  3 16 3 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5582410395145416e-002</threshold>
+            <left_val>6.1051581054925919e-002</left_val>
+            <right_val>-6.5449321269989014e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 1 -1.</_>
+                <_>
+                  9 9 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0514019988477230e-002</threshold>
+            <left_val>-1.0234809666872025e-001</left_val>
+            <right_val>2.6112779974937439e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 2 2 -1.</_>
+                <_>
+                  0 8 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1631770030362532e-004</threshold>
+            <left_val>-3.1768348813056946e-001</left_val>
+            <right_val>1.2542060017585754e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 2 2 -1.</_>
+                <_>
+                  8 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.4300020672380924e-003</threshold>
+            <left_val>1.9109399616718292e-001</left_val>
+            <right_val>-5.2662618458271027e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 2 2 -1.</_>
+                <_>
+                  3 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0806640386581421e-003</threshold>
+            <left_val>-1.4428110420703888e-001</left_val>
+            <right_val>3.0112838745117188e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 1 1 2 -1.</_>
+                <_>
+                  11 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4104570299386978e-003</threshold>
+            <left_val>-5.4554589092731476e-002</left_val>
+            <right_val>3.5240170359611511e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 1 3 -1.</_>
+                <_>
+                  4 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0801830329000950e-002</threshold>
+            <left_val>5.5018458515405655e-002</left_val>
+            <right_val>-7.4443417787551880e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 5 12 -1.</_>
+                <_>
+                  4 8 5 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.2296931147575378e-002</threshold>
+            <left_val>6.1844110488891602e-002</left_val>
+            <right_val>-3.3144399523735046e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 3 3 -1.</_>
+                <_>
+                  1 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.9895617887377739e-003</threshold>
+            <left_val>6.4745798707008362e-002</left_val>
+            <right_val>-5.6030327081680298e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 7 3 3 -1.</_>
+                <_>
+                  9 8 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.4227874651551247e-003</threshold>
+            <left_val>-3.0067789554595947e-001</left_val>
+            <right_val>4.3195281177759171e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 7 3 3 -1.</_>
+                <_>
+                  3 8 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0783370360732079e-002</threshold>
+            <left_val>3.7524980306625366e-001</left_val>
+            <right_val>-1.0968690365552902e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 1 1 2 -1.</_>
+                <_>
+                  11 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.2015861729159951e-004</threshold>
+            <left_val>-1.1337819695472717e-001</left_val>
+            <right_val>3.7144880741834641e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 1 2 -1.</_>
+                <_>
+                  0 2 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.0162001540884376e-004</threshold>
+            <left_val>-5.2545320987701416e-001</left_val>
+            <right_val>6.6209748387336731e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 17 2 1 -1.</_>
+                <_>
+                  8 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.5214110501110554e-003</threshold>
+            <left_val>-1.5936410427093506e-001</left_val>
+            <right_val>5.1849711686372757e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 17 1 2 -1.</_>
+                <_>
+                  4 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.0704779722727835e-005</threshold>
+            <left_val>-3.3334940671920776e-001</left_val>
+            <right_val>1.0919860005378723e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 6 2 4 -1.</_>
+                <_>
+                  8 6 1 2 2.</_>
+                <_>
+                  7 8 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8114539561793208e-003</threshold>
+            <left_val>1.1214060336351395e-001</left_val>
+            <right_val>-9.0960927307605743e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 8 6 6 -1.</_>
+                <_>
+                  6 8 6 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.9519029557704926e-001</threshold>
+            <left_val>-7.2080957889556885e-001</left_val>
+            <right_val>5.0182379782199860e-002</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 6 2 4 -1.</_>
+                <_>
+                  8 6 1 2 2.</_>
+                <_>
+                  7 8 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4884449541568756e-002</threshold>
+            <left_val>-6.0010558366775513e-001</left_val>
+            <right_val>9.1695934534072876e-003</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 2 4 -1.</_>
+                <_>
+                  3 6 1 2 2.</_>
+                <_>
+                  4 8 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.3493862077593803e-003</threshold>
+            <left_val>4.8005661368370056e-001</left_val>
+            <right_val>-7.6954081654548645e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 6 2 -1.</_>
+                <_>
+                  8 3 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>7.1461386978626251e-002</threshold>
+            <left_val>-5.7781968265771866e-002</left_val>
+            <right_val>2.6106640696525574e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 6 5 -1.</_>
+                <_>
+                  3 11 3 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.1590640097856522e-002</threshold>
+            <left_val>7.1806840598583221e-002</left_val>
+            <right_val>-4.6015501022338867e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 3 3 -1.</_>
+                <_>
+                  8 13 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0857140664011240e-003</threshold>
+            <left_val>-9.2065691947937012e-002</left_val>
+            <right_val>1.1266019940376282e-001</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 13 3 3 -1.</_>
+                <_>
+                  3 13 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7517179949209094e-003</threshold>
+            <left_val>-1.9908079504966736e-001</left_val>
+            <right_val>1.9879740476608276e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 6 2 -1.</_>
+                <_>
+                  8 3 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.3493461348116398e-003</threshold>
+            <left_val>-1.0544289648532867e-001</left_val>
+            <right_val>4.3338119983673096e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 2 6 -1.</_>
+                <_>
+                  4 3 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.2910311371088028e-002</threshold>
+            <left_val>5.2926450967788696e-002</left_val>
+            <right_val>-6.6493779420852661e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 7 -1.</_>
+                <_>
+                  0 0 6 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8933840990066528e-001</threshold>
+            <left_val>-5.9245282411575317e-001</left_val>
+            <right_val>5.0023719668388367e-002</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 10 3 -1.</_>
+                <_>
+                  1 10 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9839199259877205e-002</threshold>
+            <left_val>4.1037648916244507e-002</left_val>
+            <right_val>-6.7570680379867554e-001</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 4 -1.</_>
+                <_>
+                  0 10 12 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.9357530176639557e-002</threshold>
+            <left_val>-6.5960741043090820e-001</left_val>
+            <right_val>4.1811358183622360e-002</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 3 15 -1.</_>
+                <_>
+                  0 10 3 5 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8180392980575562e-002</threshold>
+            <left_val>6.5817430615425110e-002</left_val>
+            <right_val>-4.4950678944587708e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 7 18 -1.</_>
+                <_>
+                  5 9 7 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3282440602779388e-001</threshold>
+            <left_val>-2.1098449826240540e-001</left_val>
+            <right_val>3.9650738239288330e-002</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 5 -1.</_>
+                <_>
+                  2 0 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.0266319855581969e-005</threshold>
+            <left_val>-2.5888821482658386e-001</left_val>
+            <right_val>1.1488880217075348e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3127609491348267e+000</stage_threshold>
+      <parent>14</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 16 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 4 2 -1.</_>
+                <_>
+                  4 2 2 1 2.</_>
+                <_>
+                  6 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.5426998771727085e-003</threshold>
+            <left_val>-2.2366699576377869e-001</left_val>
+            <right_val>4.7720021009445190e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  7 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.2333480592351407e-004</threshold>
+            <left_val>1.0184849798679352e-001</left_val>
+            <right_val>-1.8614460527896881e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 7 6 2 -1.</_>
+                <_>
+                  3 7 3 1 2.</_>
+                <_>
+                  6 8 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.0191731899976730e-003</threshold>
+            <left_val>3.1382268667221069e-001</left_val>
+            <right_val>-2.3328569531440735e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 10 10 -1.</_>
+                <_>
+                  6 8 5 5 2.</_>
+                <_>
+                  1 13 5 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7179940640926361e-001</threshold>
+            <left_val>-2.9191988706588745e-001</left_val>
+            <right_val>2.1794080734252930e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 3 -1.</_>
+                <_>
+                  1 1 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6310229897499084e-002</threshold>
+            <left_val>-1.4051440358161926e-001</left_val>
+            <right_val>3.2606941461563110e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 17 12 3 -1.</_>
+                <_>
+                  0 17 6 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5107460319995880e-001</threshold>
+            <left_val>6.4690059423446655e-001</left_val>
+            <right_val>-5.2486609667539597e-002</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 12 -1.</_>
+                <_>
+                  0 6 1 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.6439900994300842e-002</threshold>
+            <left_val>-2.4340909719467163e-001</left_val>
+            <right_val>2.6854258775711060e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 2 1 -1.</_>
+                <_>
+                  10 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.3716500513255596e-003</threshold>
+            <left_val>-2.9228550195693970e-001</left_val>
+            <right_val>9.8407112061977386e-002</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  0 18 6 1 2.</_>
+                <_>
+                  6 19 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6864160075783730e-002</threshold>
+            <left_val>-2.8363880515098572e-001</left_val>
+            <right_val>1.9571739435195923e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 5 -1.</_>
+                <_>
+                  7 4 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.5575649924576283e-003</threshold>
+            <left_val>4.4347479939460754e-002</left_val>
+            <right_val>-1.3447460532188416e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 5 3 -1.</_>
+                <_>
+                  5 4 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.0957190543413162e-002</threshold>
+            <left_val>-1.8374939262866974e-001</left_val>
+            <right_val>2.6384368538856506e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 5 1 3 -1.</_>
+                <_>
+                  11 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.1607948951423168e-003</threshold>
+            <left_val>4.9291279166936874e-002</left_val>
+            <right_val>-6.1921811103820801e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 5 1 3 -1.</_>
+                <_>
+                  0 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.1489768773317337e-003</threshold>
+            <left_val>4.1641891002655029e-002</left_val>
+            <right_val>-7.3988562822341919e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 3 2 -1.</_>
+                <_>
+                  8 6 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.1313559263944626e-002</threshold>
+            <left_val>2.3694250732660294e-002</left_val>
+            <right_val>-5.6835669279098511e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 2 3 -1.</_>
+                <_>
+                  4 6 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2101300060749054e-002</threshold>
+            <left_val>-9.5187656581401825e-002</left_val>
+            <right_val>4.6901950240135193e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 2 1 -1.</_>
+                <_>
+                  6 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8083410104736686e-003</threshold>
+            <left_val>4.7500770539045334e-002</left_val>
+            <right_val>-3.0990800261497498e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 2 -1.</_>
+                <_>
+                  5 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0990530252456665e-002</threshold>
+            <left_val>6.7560458183288574e-001</left_val>
+            <right_val>-6.0268498957157135e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 8 1 2 -1.</_>
+                <_>
+                  11 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.9888361981138587e-004</threshold>
+            <left_val>1.6142509877681732e-001</left_val>
+            <right_val>-8.0034710466861725e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 1 2 -1.</_>
+                <_>
+                  0 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5803032561670989e-005</threshold>
+            <left_val>-2.5957980751991272e-001</left_val>
+            <right_val>1.5043449401855469e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 4 2 -1.</_>
+                <_>
+                  9 0 2 1 2.</_>
+                <_>
+                  7 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0529270395636559e-002</threshold>
+            <left_val>4.8798549175262451e-001</left_val>
+            <right_val>-1.0572060197591782e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 2 2 -1.</_>
+                <_>
+                  5 0 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.5140570942312479e-003</threshold>
+            <left_val>-5.9965860843658447e-001</left_val>
+            <right_val>7.1445137262344360e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 0 3 1 -1.</_>
+                <_>
+                  9 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0928360521793365e-002</threshold>
+            <left_val>-6.3737767934799194e-001</left_val>
+            <right_val>1.1195439845323563e-002</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 8 12 -1.</_>
+                <_>
+                  0 7 8 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.4567293524742126e-003</threshold>
+            <left_val>1.0487599670886993e-001</left_val>
+            <right_val>-3.3027571439743042e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 14 12 6 -1.</_>
+                <_>
+                  0 16 12 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1649870127439499e-001</threshold>
+            <left_val>4.9215629696846008e-002</left_val>
+            <right_val>-7.1875381469726563e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 1 3 -1.</_>
+                <_>
+                  3 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0911310091614723e-002</threshold>
+            <left_val>4.0617398917675018e-002</left_val>
+            <right_val>-7.1910649538040161e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 2 1 -1.</_>
+                <_>
+                  10 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.4141639471054077e-002</threshold>
+            <left_val>4.6759098768234253e-001</left_val>
+            <right_val>-3.2959330826997757e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 17 1 2 -1.</_>
+                <_>
+                  2 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2029770296066999e-003</threshold>
+            <left_val>-3.1624960899353027e-001</left_val>
+            <right_val>1.1505530029535294e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 2 3 1 -1.</_>
+                <_>
+                  10 3 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.8068173974752426e-003</threshold>
+            <left_val>-3.6025181412696838e-002</left_val>
+            <right_val>1.7123579978942871e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 2 1 3 -1.</_>
+                <_>
+                  2 3 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.7418841645121574e-003</threshold>
+            <left_val>6.2854416668415070e-002</left_val>
+            <right_val>-5.5376541614532471e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 11 2 2 -1.</_>
+                <_>
+                  10 12 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3345720246434212e-002</threshold>
+            <left_val>-7.5741612911224365e-001</left_val>
+            <right_val>9.3524847179651260e-003</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 8 -1.</_>
+                <_>
+                  0 11 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.8471651077270508e-002</threshold>
+            <left_val>5.5774558335542679e-002</left_val>
+            <right_val>-5.2644717693328857e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 8 2 8 -1.</_>
+                <_>
+                  5 10 2 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4308050274848938e-002</threshold>
+            <left_val>-5.0163388252258301e-001</left_val>
+            <right_val>6.1552900820970535e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 1 2 -1.</_>
+                <_>
+                  5 6 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.3234330583363771e-003</threshold>
+            <left_val>-8.7273299694061279e-002</left_val>
+            <right_val>3.7597200274467468e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 4 3 4 -1.</_>
+                <_>
+                  9 5 3 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.6605149768292904e-003</threshold>
+            <left_val>-5.6011527776718140e-001</left_val>
+            <right_val>4.5979429036378860e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 7 4 1 -1.</_>
+                <_>
+                  3 7 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.3684150073677301e-004</threshold>
+            <left_val>9.2453077435493469e-002</left_val>
+            <right_val>-3.4188869595527649e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 9 2 1 -1.</_>
+                <_>
+                  10 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.2499719895422459e-003</threshold>
+            <left_val>-1.0243079811334610e-001</left_val>
+            <right_val>3.8211381435394287e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 1 -1.</_>
+                <_>
+                  1 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.6710777143016458e-005</threshold>
+            <left_val>-1.4891329407691956e-001</left_val>
+            <right_val>2.4878869950771332e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 6 2 1 -1.</_>
+                <_>
+                  10 6 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.1435599084943533e-003</threshold>
+            <left_val>2.0501570403575897e-001</left_val>
+            <right_val>-5.9435389935970306e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 6 1 2 -1.</_>
+                <_>
+                  2 6 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.9189229351468384e-004</threshold>
+            <left_val>1.2612619996070862e-001</left_val>
+            <right_val>-3.2496848702430725e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 1 3 -1.</_>
+                <_>
+                  6 6 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.6893218532204628e-003</threshold>
+            <left_val>3.2404568791389465e-001</left_val>
+            <right_val>-3.2848190516233444e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 1 3 -1.</_>
+                <_>
+                  0 5 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0783370602875948e-003</threshold>
+            <left_val>5.5750191211700439e-002</left_val>
+            <right_val>-5.7443851232528687e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 0 4 2 -1.</_>
+                <_>
+                  9 0 2 1 2.</_>
+                <_>
+                  7 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3539710082113743e-002</threshold>
+            <left_val>-3.2638911157846451e-002</left_val>
+            <right_val>4.8875731229782104e-001</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 4 2 -1.</_>
+                <_>
+                  1 0 2 1 2.</_>
+                <_>
+                  3 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.2393882621545345e-005</threshold>
+            <left_val>-2.2491760551929474e-001</left_val>
+            <right_val>1.5178939700126648e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 3 3 -1.</_>
+                <_>
+                  6 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.3342671170830727e-003</threshold>
+            <left_val>-5.7278221845626831e-001</left_val>
+            <right_val>4.6149488538503647e-002</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 3 3 -1.</_>
+                <_>
+                  5 12 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.5541571453213692e-003</threshold>
+            <left_val>-2.0548130571842194e-001</left_val>
+            <right_val>1.4704200625419617e-001</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 1 6 -1.</_>
+                <_>
+                  6 10 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4691719561815262e-002</threshold>
+            <left_val>2.0886249840259552e-002</left_val>
+            <right_val>-5.6028658151626587e-001</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 2 1 -1.</_>
+                <_>
+                  3 9 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.7412186732981354e-005</threshold>
+            <left_val>-1.5648730099201202e-001</left_val>
+            <right_val>1.9009509682655334e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 2 -1.</_>
+                <_>
+                  9 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.7823117822408676e-003</threshold>
+            <left_val>-1.2173660099506378e-001</left_val>
+            <right_val>2.1024130284786224e-001</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 11 6 1 -1.</_>
+                <_>
+                  6 11 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.4938321709632874e-002</threshold>
+            <left_val>5.5764448642730713e-001</left_val>
+            <right_val>-6.1514221131801605e-002</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 15 1 3 -1.</_>
+                <_>
+                  6 16 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.9424177743494511e-003</threshold>
+            <left_val>-4.4680491089820862e-001</left_val>
+            <right_val>5.5648550391197205e-002</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 16 6 2 -1.</_>
+                <_>
+                  2 16 3 1 2.</_>
+                <_>
+                  5 17 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.0992597825825214e-003</threshold>
+            <left_val>1.9794790446758270e-001</left_val>
+            <right_val>-1.8055149912834167e-001</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 2 6 -1.</_>
+                <_>
+                  6 1 1 6 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.5280229970812798e-002</threshold>
+            <left_val>-8.6270570755004883e-002</left_val>
+            <right_val>3.5552538931369781e-002</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 1 6 2 -1.</_>
+                <_>
+                  6 1 6 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-7.4432790279388428e-003</threshold>
+            <left_val>1.7408570647239685e-001</left_val>
+            <right_val>-1.8400490283966064e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 1 -1.</_>
+                <_>
+                  9 9 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.1331128925085068e-003</threshold>
+            <left_val>-8.8491149246692657e-002</left_val>
+            <right_val>3.1532418727874756e-001</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 3 1 -1.</_>
+                <_>
+                  2 9 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.4648790713399649e-003</threshold>
+            <left_val>-8.3607397973537445e-002</left_val>
+            <right_val>3.5939309000968933e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3777979612350464e+000</stage_threshold>
+      <parent>15</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 17 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 2 6 1 -1.</_>
+                <_>
+                  8 4 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.2584890723228455e-002</threshold>
+            <left_val>-2.9446709156036377e-001</left_val>
+            <right_val>3.8783320784568787e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 7 2 4 -1.</_>
+                <_>
+                  8 7 1 2 2.</_>
+                <_>
+                  7 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5954829752445221e-002</threshold>
+            <left_val>-8.7387222051620483e-001</left_val>
+            <right_val>1.3140209950506687e-002</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 7 2 4 -1.</_>
+                <_>
+                  3 7 1 2 2.</_>
+                <_>
+                  4 9 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.5294029191136360e-003</threshold>
+            <left_val>-1.8746000528335571e-001</left_val>
+            <right_val>3.4920379519462585e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.9139063358306885e-002</threshold>
+            <left_val>-3.2066041231155396e-001</left_val>
+            <right_val>2.1070230752229691e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 4 5 12 -1.</_>
+                <_>
+                  2 7 5 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7401080355048180e-002</threshold>
+            <left_val>1.6137300431728363e-001</left_val>
+            <right_val>-3.3988159894943237e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 7 18 -1.</_>
+                <_>
+                  5 9 7 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4834091663360596e-001</threshold>
+            <left_val>-1.1290470138192177e-002</left_val>
+            <right_val>-1.0005040168762207e+000</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 7 18 -1.</_>
+                <_>
+                  0 9 7 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.6463169157505035e-002</threshold>
+            <left_val>-7.0668822526931763e-001</left_val>
+            <right_val>5.8523610234260559e-002</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 9 1 6 -1.</_>
+                <_>
+                  11 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5692781209945679e-002</threshold>
+            <left_val>-1.2722860090434551e-002</left_val>
+            <right_val>5.1669907569885254e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 4 2 -1.</_>
+                <_>
+                  4 0 2 1 2.</_>
+                <_>
+                  6 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.8253971189260483e-003</threshold>
+            <left_val>3.5113370418548584e-001</left_val>
+            <right_val>-1.2264049798250198e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 7 1 6 -1.</_>
+                <_>
+                  11 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4928439408540726e-002</threshold>
+            <left_val>-4.1226190328598022e-001</left_val>
+            <right_val>8.2819983363151550e-003</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 1 6 -1.</_>
+                <_>
+                  0 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.3438487490639091e-004</threshold>
+            <left_val>-3.1004768610000610e-001</left_val>
+            <right_val>1.2824219465255737e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 2 3 -1.</_>
+                <_>
+                  5 0 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.3677380308508873e-003</threshold>
+            <left_val>8.7895832955837250e-002</left_val>
+            <right_val>-5.5109828710556030e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 15 6 2 -1.</_>
+                <_>
+                  3 15 3 1 2.</_>
+                <_>
+                  6 16 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.0594570823013783e-003</threshold>
+            <left_val>2.3694829642772675e-001</left_val>
+            <right_val>-1.6963149607181549e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  6 13 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.3386299833655357e-002</threshold>
+            <left_val>-2.9353159666061401e-001</left_val>
+            <right_val>3.3642090857028961e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 11 8 5 -1.</_>
+                <_>
+                  4 11 4 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.5047020316123962e-002</threshold>
+            <left_val>9.9271617829799652e-002</left_val>
+            <right_val>-4.0973669290542603e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 5 -1.</_>
+                <_>
+                  10 1 1 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7345769330859184e-002</threshold>
+            <left_val>-1.0950370132923126e-001</left_val>
+            <right_val>4.2251870036125183e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 12 13 -1.</_>
+                <_>
+                  6 7 6 13 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.1694452762603760e-001</threshold>
+            <left_val>-5.7410959154367447e-002</left_val>
+            <right_val>6.4137631654739380e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 8 -1.</_>
+                <_>
+                  6 10 3 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>6.5628431737422943e-002</threshold>
+            <left_val>3.3641148358583450e-002</left_val>
+            <right_val>-6.0003411769866943e-001</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 8 8 3 -1.</_>
+                <_>
+                  6 10 4 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0161089897155762e-001</threshold>
+            <left_val>-2.5070580840110779e-001</left_val>
+            <right_val>1.8186099827289581e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 0 10 3 -1.</_>
+                <_>
+                  1 1 10 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9830370098352432e-002</threshold>
+            <left_val>-1.1608160287141800e-001</left_val>
+            <right_val>3.5246831178665161e-001</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 1 2 -1.</_>
+                <_>
+                  0 3 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-6.6538550890982151e-004</threshold>
+            <left_val>-5.6480127573013306e-001</left_val>
+            <right_val>6.4513862133026123e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 2 3 -1.</_>
+                <_>
+                  9 13 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.9011844247579575e-003</threshold>
+            <left_val>3.7113070487976074e-002</left_val>
+            <right_val>-6.2943869829177856e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 12 2 3 -1.</_>
+                <_>
+                  1 13 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.7988148182630539e-003</threshold>
+            <left_val>3.3002421259880066e-001</left_val>
+            <right_val>-1.1569269746541977e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 0 3 1 -1.</_>
+                <_>
+                  10 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.8202450126409531e-002</threshold>
+            <left_val>2.2297389805316925e-002</left_val>
+            <right_val>-6.8679827451705933e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 1 3 -1.</_>
+                <_>
+                  2 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.3430098816752434e-003</threshold>
+            <left_val>-5.9504687786102295e-001</left_val>
+            <right_val>5.3902018815279007e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.0256610065698624e-001</threshold>
+            <left_val>1.1425909586250782e-002</left_val>
+            <right_val>-3.4088680148124695e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.1729130297899246e-002</threshold>
+            <left_val>1.0024060308933258e-001</left_val>
+            <right_val>-3.6016431450843811e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 5 2 3 -1.</_>
+                <_>
+                  7 5 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-4.0402188897132874e-002</threshold>
+            <left_val>-7.9971337318420410e-001</left_val>
+            <right_val>1.0374830104410648e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 2 -1.</_>
+                <_>
+                  5 5 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.1156830005347729e-002</threshold>
+            <left_val>4.1818261146545410e-001</left_val>
+            <right_val>-1.0622619837522507e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 10 2 1 -1.</_>
+                <_>
+                  8 10 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0242810240015388e-003</threshold>
+            <left_val>-7.2071209549903870e-002</left_val>
+            <right_val>9.9886089563369751e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 10 2 1 -1.</_>
+                <_>
+                  3 10 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.5549278194084764e-004</threshold>
+            <left_val>-1.6656149923801422e-001</left_val>
+            <right_val>2.7860009670257568e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 4 4 2 -1.</_>
+                <_>
+                  4 5 4 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3702700380235910e-004</threshold>
+            <left_val>-3.1575959920883179e-001</left_val>
+            <right_val>1.1808790266513824e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 12 9 -1.</_>
+                <_>
+                  3 9 6 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9174149632453918e-001</threshold>
+            <left_val>5.2235382795333862e-001</left_val>
+            <right_val>-7.6672300696372986e-002</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 12 1 3 -1.</_>
+                <_>
+                  9 13 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5123620871454477e-003</threshold>
+            <left_val>-8.5517987608909607e-002</left_val>
+            <right_val>2.7882871031761169e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 12 1 3 -1.</_>
+                <_>
+                  2 13 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.6384440027177334e-003</threshold>
+            <left_val>-1.0173840075731277e-001</left_val>
+            <right_val>3.6575859785079956e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 3 5 -1.</_>
+                <_>
+                  7 13 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.1068800538778305e-003</threshold>
+            <left_val>-1.9999110698699951e-001</left_val>
+            <right_val>3.5431660711765289e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 5 3 -1.</_>
+                <_>
+                  5 13 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.5456059724092484e-002</threshold>
+            <left_val>-6.6976618766784668e-001</left_val>
+            <right_val>5.1672291010618210e-002</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 17 6 3 -1.</_>
+                <_>
+                  3 18 6 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.5856729596853256e-002</threshold>
+            <left_val>-7.3498648405075073e-001</left_val>
+            <right_val>2.7689380571246147e-002</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 15 2 4 -1.</_>
+                <_>
+                  5 16 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.5871294140815735e-003</threshold>
+            <left_val>-1.1443380266427994e-001</left_val>
+            <right_val>2.7319890260696411e-001</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 18 3 2 -1.</_>
+                <_>
+                  8 18 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.5716209094971418e-003</threshold>
+            <left_val>6.0280900448560715e-002</left_val>
+            <right_val>-2.6631888747215271e-001</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 4 2 4 -1.</_>
+                <_>
+                  1 5 2 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0332760401070118e-002</threshold>
+            <left_val>3.8581959903240204e-002</left_val>
+            <right_val>-6.7532962560653687e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 3 -1.</_>
+                <_>
+                  9 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.3224009722471237e-003</threshold>
+            <left_val>2.5268268585205078e-001</left_val>
+            <right_val>-6.8770729005336761e-002</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 4 3 2 -1.</_>
+                <_>
+                  3 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.8182119820266962e-003</threshold>
+            <left_val>-3.1761169433593750e-001</left_val>
+            <right_val>9.2666782438755035e-002</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 1 -1.</_>
+                <_>
+                  7 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.3169780373573303e-002</threshold>
+            <left_val>-5.3651332855224609e-001</left_val>
+            <right_val>2.8106879442930222e-002</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 6 2 3 -1.</_>
+                <_>
+                  5 7 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.0408600568771362e-002</threshold>
+            <left_val>-6.0603220015764236e-002</left_val>
+            <right_val>5.0572431087493896e-001</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  8 5 2 6 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.7321230471134186e-001</threshold>
+            <left_val>2.1015009842813015e-003</left_val>
+            <right_val>3.2260191440582275e-001</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 6 -1.</_>
+                <_>
+                  4 5 6 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.8910921216011047e-002</threshold>
+            <left_val>1.4044930040836334e-001</left_val>
+            <right_val>-2.0362600684165955e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 4 2 3 -1.</_>
+                <_>
+                  10 5 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.9123559147119522e-003</threshold>
+            <left_val>7.1367353200912476e-002</left_val>
+            <right_val>-5.0733560323715210e-001</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 1 2 -1.</_>
+                <_>
+                  0 19 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3819620653521270e-004</threshold>
+            <left_val>7.6624020934104919e-002</left_val>
+            <right_val>-3.4903231263160706e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 12 8 -1.</_>
+                <_>
+                  0 5 12 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.2017219560220838e-003</threshold>
+            <left_val>-5.1169282197952271e-001</left_val>
+            <right_val>5.4793931543827057e-002</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 2 3 -1.</_>
+                <_>
+                  0 5 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.4135429672896862e-003</threshold>
+            <left_val>-5.0181478261947632e-001</left_val>
+            <right_val>5.0226181745529175e-002</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 6 3 2 -1.</_>
+                <_>
+                  8 7 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.3707648515701294e-002</threshold>
+            <left_val>-8.5764700174331665e-001</left_val>
+            <right_val>4.7642397694289684e-003</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 6 2 3 -1.</_>
+                <_>
+                  4 7 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2718940153717995e-002</threshold>
+            <left_val>-1.0830610245466232e-001</left_val>
+            <right_val>2.8867751359939575e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 2 -1.</_>
+                <_>
+                  7 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.0672269165515900e-002</threshold>
+            <left_val>-3.0906811356544495e-001</left_val>
+            <right_val>2.1581029519438744e-002</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 2 3 -1.</_>
+                <_>
+                  5 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.5933969989418983e-002</threshold>
+            <left_val>-8.3755359053611755e-002</left_val>
+            <right_val>4.1743949055671692e-001</right_val></_></_>
+        <_>
+          <!-- tree 55 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 3 2 -1.</_>
+                <_>
+                  6 0 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.3405526131391525e-003</threshold>
+            <left_val>4.7591928392648697e-002</left_val>
+            <right_val>-6.5143817663192749e-001</right_val></_></_>
+        <_>
+          <!-- tree 56 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 15 3 2 -1.</_>
+                <_>
+                  5 15 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.3016579672694206e-002</threshold>
+            <left_val>5.3528260439634323e-002</left_val>
+            <right_val>-4.8644289374351501e-001</right_val></_></_></trees>
+      <stage_threshold>-1.2673230171203613e+000</stage_threshold>
+      <parent>16</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 18 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 1 3 -1.</_>
+                <_>
+                  5 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.0423052161931992e-003</threshold>
+            <left_val>-2.2111539542675018e-001</left_val>
+            <right_val>4.3673288822174072e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 4 3 -1.</_>
+                <_>
+                  5 5 4 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.3594230189919472e-003</threshold>
+            <left_val>-1.7003799974918365e-001</left_val>
+            <right_val>1.2387859821319580e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 3 3 -1.</_>
+                <_>
+                  4 7 1 1 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.2854709997773170e-002</threshold>
+            <left_val>3.0707350373268127e-001</left_val>
+            <right_val>-1.9186529517173767e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 16 1 4 -1.</_>
+                <_>
+                  7 18 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>4.3850108049809933e-003</threshold>
+            <left_val>3.2038759440183640e-002</left_val>
+            <right_val>-1.4620819687843323e-001</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 16 1 4 -1.</_>
+                <_>
+                  4 18 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.3011639975011349e-003</threshold>
+            <left_val>1.6375949978828430e-001</left_val>
+            <right_val>-2.8174880146980286e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 1 6 -1.</_>
+                <_>
+                  6 13 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.9680870026350021e-002</threshold>
+            <left_val>4.2250480502843857e-002</left_val>
+            <right_val>-6.0391640663146973e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 13 6 1 -1.</_>
+                <_>
+                  6 13 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.1453109830617905e-002</threshold>
+            <left_val>6.5720152854919434e-001</left_val>
+            <right_val>-7.0812806487083435e-002</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 1 6 -1.</_>
+                <_>
+                  4 9 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.7113489806652069e-002</threshold>
+            <left_val>2.9805190861225128e-002</left_val>
+            <right_val>-4.0825900435447693e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 6 1 -1.</_>
+                <_>
+                  8 9 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.3578230291604996e-002</threshold>
+            <left_val>-3.0918011069297791e-001</left_val>
+            <right_val>2.1382910013198853e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 9 1 6 -1.</_>
+                <_>
+                  11 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.9583559371531010e-003</threshold>
+            <left_val>2.3970389738678932e-002</left_val>
+            <right_val>-1.6768220067024231e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 1 6 -1.</_>
+                <_>
+                  0 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.8374159592203796e-004</threshold>
+            <left_val>1.9550369679927826e-001</left_val>
+            <right_val>-2.6317828893661499e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 1 -1.</_>
+                <_>
+                  3 0 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.8295589387416840e-002</threshold>
+            <left_val>-8.1490896642208099e-002</left_val>
+            <right_val>4.1922101378440857e-001</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 0 6 8 -1.</_>
+                <_>
+                  3 4 6 4 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0575760155916214e-002</threshold>
+            <left_val>-5.5699461698532104e-001</left_val>
+            <right_val>6.0772120952606201e-002</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 3 6 12 -1.</_>
+                <_>
+                  3 7 6 4 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3283690204843879e-003</threshold>
+            <left_val>9.2958763241767883e-002</left_val>
+            <right_val>-3.3554950356483459e-001</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 6 1 2 -1.</_>
+                <_>
+                  4 7 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8217159667983651e-003</threshold>
+            <left_val>-9.9800482392311096e-002</left_val>
+            <right_val>3.8015770912170410e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8067359924316406e-003</threshold>
+            <left_val>-5.1108711957931519e-001</left_val>
+            <right_val>6.8366326391696930e-002</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 12 8 3 -1.</_>
+                <_>
+                  4 12 4 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>6.6835001111030579e-002</threshold>
+            <left_val>3.1457249075174332e-002</left_val>
+            <right_val>-6.9415211677551270e-001</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 4 -1.</_>
+                <_>
+                  11 0 1 2 2.</_>
+                <_>
+                  10 2 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3109239749610424e-002</threshold>
+            <left_val>6.0284411907196045e-001</left_val>
+            <right_val>-8.0423787236213684e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 4 -1.</_>
+                <_>
+                  0 0 1 2 2.</_>
+                <_>
+                  1 2 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9930349662899971e-003</threshold>
+            <left_val>-4.1979709267616272e-001</left_val>
+            <right_val>8.9367941021919250e-002</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 0 2 1 -1.</_>
+                <_>
+                  10 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0855719447135925e-003</threshold>
+            <left_val>-2.4703420698642731e-001</left_val>
+            <right_val>5.2764680236577988e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 2 1 -1.</_>
+                <_>
+                  1 0 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.0320110488682985e-003</threshold>
+            <left_val>-6.1820042133331299e-001</left_val>
+            <right_val>5.1938790827989578e-002</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 9 2 6 -1.</_>
+                <_>
+                  11 9 1 3 2.</_>
+                <_>
+                  10 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6026819124817848e-002</threshold>
+            <left_val>-8.5486106574535370e-002</left_val>
+            <right_val>5.8234047889709473e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 10 12 3 -1.</_>
+                <_>
+                  0 11 12 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7896020784974098e-002</threshold>
+            <left_val>6.8894177675247192e-002</left_val>
+            <right_val>-5.8082962036132813e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 11 1 3 -1.</_>
+                <_>
+                  7 12 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.4853560607880354e-003</threshold>
+            <left_val>2.0646420121192932e-001</left_val>
+            <right_val>-6.0466051101684570e-002</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 1 3 -1.</_>
+                <_>
+                  4 12 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8073250539600849e-003</threshold>
+            <left_val>2.5038561224937439e-001</left_val>
+            <right_val>-1.3862800598144531e-001</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 11 2 3 -1.</_>
+                <_>
+                  6 12 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1800680309534073e-002</threshold>
+            <left_val>-5.5517327785491943e-001</left_val>
+            <right_val>2.3907609283924103e-002</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 2 3 -1.</_>
+                <_>
+                  4 12 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.3180782124400139e-003</threshold>
+            <left_val>-1.0365380346775055e-001</left_val>
+            <right_val>3.5622540116310120e-001</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 3 1 -1.</_>
+                <_>
+                  7 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.9885929941665381e-004</threshold>
+            <left_val>7.9137459397315979e-002</left_val>
+            <right_val>-7.1248553693294525e-002</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 1 3 -1.</_>
+                <_>
+                  5 1 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2722889892756939e-002</threshold>
+            <left_val>3.6043450236320496e-002</left_val>
+            <right_val>-7.7585661411285400e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 1 4 2 -1.</_>
+                <_>
+                  6 1 2 1 2.</_>
+                <_>
+                  4 2 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.4894611239433289e-003</threshold>
+            <left_val>-1.1198099702596664e-001</left_val>
+            <right_val>2.9539060592651367e-001</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 2 6 -1.</_>
+                <_>
+                  4 2 2 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>3.1117599457502365e-002</threshold>
+            <left_val>6.8027697503566742e-002</left_val>
+            <right_val>-4.7621628642082214e-001</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 9 2 6 -1.</_>
+                <_>
+                  11 9 1 3 2.</_>
+                <_>
+                  10 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.0922919958829880e-002</threshold>
+            <left_val>3.7011030316352844e-001</left_val>
+            <right_val>-1.5059700608253479e-001</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 9 2 6 -1.</_>
+                <_>
+                  0 9 1 3 2.</_>
+                <_>
+                  1 12 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.7167469486594200e-003</threshold>
+            <left_val>2.7644971013069153e-001</left_val>
+            <right_val>-1.1304590106010437e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 8 6 2 -1.</_>
+                <_>
+                  3 9 6 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.3501050416380167e-003</threshold>
+            <left_val>-3.5303080081939697e-001</left_val>
+            <right_val>9.9187247455120087e-002</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 8 12 3 -1.</_>
+                <_>
+                  0 9 12 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9909780472517014e-002</threshold>
+            <left_val>6.5169408917427063e-002</left_val>
+            <right_val>-4.9353629350662231e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 3 2 -1.</_>
+                <_>
+                  7 5 1 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.3044180124998093e-002</threshold>
+            <left_val>1.7247360199689865e-002</left_val>
+            <right_val>-3.9788180589675903e-001</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 2 3 -1.</_>
+                <_>
+                  5 5 2 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>9.6177039667963982e-003</threshold>
+            <left_val>-1.1394459754228592e-001</left_val>
+            <right_val>3.1357648968696594e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 7 1 2 -1.</_>
+                <_>
+                  11 8 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.6275239698588848e-003</threshold>
+            <left_val>-9.2318731546401978e-001</left_val>
+            <right_val>7.8877164050936699e-003</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 7 1 2 -1.</_>
+                <_>
+                  0 8 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.7190303020179272e-005</threshold>
+            <left_val>-3.0970078706741333e-001</left_val>
+            <right_val>9.5611982047557831e-002</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 0 4 2 -1.</_>
+                <_>
+                  7 0 2 1 2.</_>
+                <_>
+                  5 1 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1889990419149399e-002</threshold>
+            <left_val>4.7901371121406555e-001</left_val>
+            <right_val>-3.5577189177274704e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 3 3 -1.</_>
+                <_>
+                  5 0 1 3 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>8.4557365626096725e-003</threshold>
+            <left_val>5.2709650248289108e-002</left_val>
+            <right_val>-5.7321697473526001e-001</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 2 3 -1.</_>
+                <_>
+                  8 5 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1996040120720863e-002</threshold>
+            <left_val>1.9709009677171707e-002</left_val>
+            <right_val>-6.9532912969589233e-001</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 0 6 2 -1.</_>
+                <_>
+                  2 0 3 1 2.</_>
+                <_>
+                  5 1 3 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7005810290575027e-002</threshold>
+            <left_val>5.9652292728424072e-001</left_val>
+            <right_val>-5.1673818379640579e-002</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 17 1 3 -1.</_>
+                <_>
+                  10 18 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.8543410114943981e-003</threshold>
+            <left_val>7.2791919112205505e-002</left_val>
+            <right_val>-5.0846791267395020e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 4 4 -1.</_>
+                <_>
+                  0 2 4 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.5675587868317962e-004</threshold>
+            <left_val>-3.8867241144180298e-001</left_val>
+            <right_val>6.5925061702728271e-002</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 2 3 -1.</_>
+                <_>
+                  8 5 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.8905180990695953e-002</threshold>
+            <left_val>-6.0740387439727783e-001</left_val>
+            <right_val>3.5101689863950014e-003</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 5 3 2 -1.</_>
+                <_>
+                  4 5 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.7714940048754215e-003</threshold>
+            <left_val>1.7274090647697449e-001</left_val>
+            <right_val>-1.7644210159778595e-001</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 1 -1.</_>
+                <_>
+                  7 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-9.1350553557276726e-003</threshold>
+            <left_val>-2.8621628880500793e-001</left_val>
+            <right_val>3.0258299782872200e-002</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 1 3 -1.</_>
+                <_>
+                  5 6 1 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.5439298264682293e-003</threshold>
+            <left_val>-8.5076972842216492e-002</left_val>
+            <right_val>4.1360539197921753e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  10 1 2 7 -1.</_>
+                <_>
+                  10 1 1 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.5785360708832741e-002</threshold>
+            <left_val>-9.6528999507427216e-002</left_val>
+            <right_val>2.8125289082527161e-001</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 1 2 8 -1.</_>
+                <_>
+                  1 1 1 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7944289371371269e-002</threshold>
+            <left_val>5.0230890512466431e-002</left_val>
+            <right_val>-6.4134520292282104e-001</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 11 1 6 -1.</_>
+                <_>
+                  11 11 1 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.8975570350885391e-002</threshold>
+            <left_val>-2.5966680049896240e-001</left_val>
+            <right_val>3.0592629685997963e-002</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 11 6 1 -1.</_>
+                <_>
+                  1 11 3 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>5.2373361540958285e-004</threshold>
+            <left_val>1.0446350276470184e-001</left_val>
+            <right_val>-3.1365889310836792e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 6 3 -1.</_>
+                <_>
+                  8 5 2 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.5457229465246201e-002</threshold>
+            <left_val>-1.6731269657611847e-001</left_val>
+            <right_val>3.7427790462970734e-002</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 6 6 -1.</_>
+                <_>
+                  2 4 2 2 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.2908679693937302e-002</threshold>
+            <left_val>-4.0295800566673279e-001</left_val>
+            <right_val>6.5455727279186249e-002</right_val></_></_>
+        <_>
+          <!-- tree 55 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 3 4 1 -1.</_>
+                <_>
+                  9 4 2 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-5.1728109829127789e-003</threshold>
+            <left_val>3.1299790740013123e-001</left_val>
+            <right_val>-7.0367880165576935e-002</right_val></_></_>
+        <_>
+          <!-- tree 56 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 3 1 4 -1.</_>
+                <_>
+                  3 4 1 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.8753990298137069e-004</threshold>
+            <left_val>1.5299630165100098e-001</left_val>
+            <right_val>-2.0695990324020386e-001</right_val></_></_>
+        <_>
+          <!-- tree 57 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 4 2 -1.</_>
+                <_>
+                  6 14 2 1 2.</_>
+                <_>
+                  4 15 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9984589889645576e-003</threshold>
+            <left_val>2.6436290144920349e-001</left_val>
+            <right_val>-1.0118020325899124e-001</right_val></_></_>
+        <_>
+          <!-- tree 58 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 16 1 4 -1.</_>
+                <_>
+                  5 17 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.7929560057818890e-003</threshold>
+            <left_val>2.8518161177635193e-001</left_val>
+            <right_val>-1.0743419826030731e-001</right_val></_></_>
+        <_>
+          <!-- tree 59 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 3 5 -1.</_>
+                <_>
+                  7 13 1 5 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.5540980994701385e-002</threshold>
+            <left_val>4.5009840279817581e-002</left_val>
+            <right_val>-2.0425949990749359e-001</right_val></_></_>
+        <_>
+          <!-- tree 60 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 12 5 3 -1.</_>
+                <_>
+                  5 13 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>2.4831600487232208e-002</threshold>
+            <left_val>4.9255561083555222e-002</left_val>
+            <right_val>-6.0236537456512451e-001</right_val></_></_></trees>
+      <stage_threshold>-1.3531359434127808e+000</stage_threshold>
+      <parent>17</parent>
+      <next>-1</next></_>
+    <_>
+      <!-- stage 19 -->
+      <trees>
+        <_>
+          <!-- tree 0 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 2 4 2 -1.</_>
+                <_>
+                  4 2 2 1 2.</_>
+                <_>
+                  6 3 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.9991321973502636e-003</threshold>
+            <left_val>-2.6711270213127136e-001</left_val>
+            <right_val>3.5392650961875916e-001</right_val></_></_>
+        <_>
+          <!-- tree 1 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 8 3 3 -1.</_>
+                <_>
+                  9 9 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1023290455341339e-002</threshold>
+            <left_val>-1.0786689817905426e-001</left_val>
+            <right_val>1.0729049891233444e-001</right_val></_></_>
+        <_>
+          <!-- tree 2 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 4 5 3 -1.</_>
+                <_>
+                  4 5 5 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.7521351128816605e-002</threshold>
+            <left_val>3.0647391080856323e-001</left_val>
+            <right_val>-2.1749919652938843e-001</right_val></_></_>
+        <_>
+          <!-- tree 3 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 17 2 3 -1.</_>
+                <_>
+                  9 18 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.7670729905366898e-003</threshold>
+            <left_val>-3.9869681000709534e-001</left_val>
+            <right_val>8.7402120232582092e-002</right_val></_></_>
+        <_>
+          <!-- tree 4 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 17 2 3 -1.</_>
+                <_>
+                  1 18 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9890109542757273e-003</threshold>
+            <left_val>-3.2719919085502625e-001</left_val>
+            <right_val>2.0264029502868652e-001</right_val></_></_>
+        <_>
+          <!-- tree 5 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 2 4 10 -1.</_>
+                <_>
+                  10 2 2 5 2.</_>
+                <_>
+                  8 7 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9364669919013977e-002</threshold>
+            <left_val>-5.1705140620470047e-002</left_val>
+            <right_val>1.2021850049495697e-001</right_val></_></_>
+        <_>
+          <!-- tree 6 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 4 10 -1.</_>
+                <_>
+                  0 2 2 5 2.</_>
+                <_>
+                  2 7 2 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.1918369680643082e-002</threshold>
+            <left_val>1.2546530365943909e-001</left_val>
+            <right_val>-3.7106749415397644e-001</right_val></_></_>
+        <_>
+          <!-- tree 7 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 5 -1.</_>
+                <_>
+                  3 13 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.5910847187042236e-002</threshold>
+            <left_val>-1.7389330267906189e-001</left_val>
+            <right_val>2.2600440680980682e-001</right_val></_></_>
+        <_>
+          <!-- tree 8 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 18 12 2 -1.</_>
+                <_>
+                  6 18 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.0751710087060928e-001</threshold>
+            <left_val>-7.8588336706161499e-002</left_val>
+            <right_val>5.7250618934631348e-001</right_val></_></_>
+        <_>
+          <!-- tree 9 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 5 6 -1.</_>
+                <_>
+                  4 17 5 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.1022340059280396e-002</threshold>
+            <left_val>1.4575169980525970e-001</left_val>
+            <right_val>-3.2396531105041504e-001</right_val></_></_>
+        <_>
+          <!-- tree 10 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 12 3 -1.</_>
+                <_>
+                  0 1 12 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6883790493011475e-002</threshold>
+            <left_val>-1.6565980017185211e-001</left_val>
+            <right_val>2.9082998633384705e-001</right_val></_></_>
+        <_>
+          <!-- tree 11 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 12 2 -1.</_>
+                <_>
+                  0 4 12 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>5.0262849981663749e-005</threshold>
+            <left_val>-5.7035660743713379e-001</left_val>
+            <right_val>6.2110569328069687e-002</right_val></_></_>
+        <_>
+          <!-- tree 12 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 8 8 -1.</_>
+                <_>
+                  2 0 4 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>9.1006923466920853e-003</threshold>
+            <left_val>5.5405318737030029e-002</left_val>
+            <right_val>-4.9272969365119934e-001</right_val></_></_>
+        <_>
+          <!-- tree 13 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 10 6 3 -1.</_>
+                <_>
+                  6 10 3 3 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6937600076198578e-001</threshold>
+            <left_val>5.4915368556976318e-001</left_val>
+            <right_val>-3.9581310003995895e-002</right_val></_></_>
+        <_>
+          <!-- tree 14 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 10 6 4 -1.</_>
+                <_>
+                  4 10 6 2 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.9913749769330025e-002</threshold>
+            <left_val>9.4958506524562836e-002</left_val>
+            <right_val>-5.1041561365127563e-001</right_val></_></_>
+        <_>
+          <!-- tree 15 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 0 2 2 -1.</_>
+                <_>
+                  7 0 1 1 2.</_>
+                <_>
+                  6 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0223759822547436e-003</threshold>
+            <left_val>-6.3331179320812225e-002</left_val>
+            <right_val>2.0407359302043915e-001</right_val></_></_>
+        <_>
+          <!-- tree 16 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 0 2 2 -1.</_>
+                <_>
+                  4 0 1 1 2.</_>
+                <_>
+                  5 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.5423391275107861e-003</threshold>
+            <left_val>4.2783120274543762e-001</left_val>
+            <right_val>-7.8888073563575745e-002</right_val></_></_>
+        <_>
+          <!-- tree 17 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 5 2 -1.</_>
+                <_>
+                  7 13 5 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-3.5147000104188919e-002</threshold>
+            <left_val>-6.1061471700668335e-001</left_val>
+            <right_val>2.5506079196929932e-002</right_val></_></_>
+        <_>
+          <!-- tree 18 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 3 -1.</_>
+                <_>
+                  0 1 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0077088847756386e-003</threshold>
+            <left_val>6.3804052770137787e-002</left_val>
+            <right_val>-4.4934588670730591e-001</right_val></_></_>
+        <_>
+          <!-- tree 19 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.5540630556643009e-003</threshold>
+            <left_val>-4.0192028880119324e-001</left_val>
+            <right_val>3.1636688858270645e-002</right_val></_></_>
+        <_>
+          <!-- tree 20 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 5 3 3 -1.</_>
+                <_>
+                  4 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4254899695515633e-002</threshold>
+            <left_val>-7.9566307365894318e-002</left_val>
+            <right_val>3.8706529140472412e-001</right_val></_></_>
+        <_>
+          <!-- tree 21 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 4 -1.</_>
+                <_>
+                  7 4 1 4 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.1024920269846916e-002</threshold>
+            <left_val>6.7027233541011810e-002</left_val>
+            <right_val>-2.8063619136810303e-001</right_val></_></_>
+        <_>
+          <!-- tree 22 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 6 2 4 -1.</_>
+                <_>
+                  3 6 1 2 2.</_>
+                <_>
+                  4 8 1 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-5.1981899887323380e-003</threshold>
+            <left_val>3.6570119857788086e-001</left_val>
+            <right_val>-1.1679860204458237e-001</right_val></_></_>
+        <_>
+          <!-- tree 23 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 5 2 -1.</_>
+                <_>
+                  7 13 5 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>4.9434448592364788e-003</threshold>
+            <left_val>4.9997199326753616e-002</left_val>
+            <right_val>-1.4642210304737091e-001</right_val></_></_>
+        <_>
+          <!-- tree 24 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  5 13 2 5 -1.</_>
+                <_>
+                  5 13 1 5 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-1.6670800745487213e-002</threshold>
+            <left_val>-4.9238750338554382e-001</left_val>
+            <right_val>6.1317440122365952e-002</right_val></_></_>
+        <_>
+          <!-- tree 25 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  11 0 1 2 -1.</_>
+                <_>
+                  11 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>7.7939140610396862e-003</threshold>
+            <left_val>-2.9953140765428543e-002</left_val>
+            <right_val>2.3316749930381775e-001</right_val></_></_>
+        <_>
+          <!-- tree 26 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 0 1 2 -1.</_>
+                <_>
+                  0 1 1 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.4590610517188907e-003</threshold>
+            <left_val>-5.7006311416625977e-001</left_val>
+            <right_val>5.3406499326229095e-002</right_val></_></_>
+        <_>
+          <!-- tree 27 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  5 6 3 1 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-2.2517830133438110e-002</threshold>
+            <left_val>1.1464659869670868e-001</left_val>
+            <right_val>-1.2585699558258057e-001</right_val></_></_>
+        <_>
+          <!-- tree 28 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 5 3 3 -1.</_>
+                <_>
+                  7 6 1 3 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.4919370412826538e-002</threshold>
+            <left_val>5.2204128354787827e-002</left_val>
+            <right_val>-5.6187790632247925e-001</right_val></_></_>
+        <_>
+          <!-- tree 29 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 15 12 5 -1.</_>
+                <_>
+                  3 15 6 5 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8656760454177856e-001</threshold>
+            <left_val>6.0989791154861450e-001</left_val>
+            <right_val>-5.0142709165811539e-002</right_val></_></_>
+        <_>
+          <!-- tree 30 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 17 1 2 -1.</_>
+                <_>
+                  3 17 1 1 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>1.2466400221455842e-004</threshold>
+            <left_val>-3.2725819945335388e-001</left_val>
+            <right_val>8.6407169699668884e-002</right_val></_></_>
+        <_>
+          <!-- tree 31 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-8.5008898749947548e-003</threshold>
+            <left_val>4.0898931026458740e-001</left_val>
+            <right_val>-8.6464531719684601e-002</right_val></_></_>
+        <_>
+          <!-- tree 32 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 14 4 6 -1.</_>
+                <_>
+                  1 14 2 3 2.</_>
+                <_>
+                  3 17 2 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.4465590007603168e-002</threshold>
+            <left_val>5.5936750024557114e-002</left_val>
+            <right_val>-5.2939140796661377e-001</right_val></_></_>
+        <_>
+          <!-- tree 33 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.1536439880728722e-002</threshold>
+            <left_val>-9.3967936933040619e-002</left_val>
+            <right_val>4.0461421012878418e-001</right_val></_></_>
+        <_>
+          <!-- tree 34 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 9 8 3 -1.</_>
+                <_>
+                  2 10 8 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.6789000481367111e-002</threshold>
+            <left_val>4.9098148941993713e-002</left_val>
+            <right_val>-6.1509531736373901e-001</right_val></_></_>
+        <_>
+          <!-- tree 35 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 9 3 2 -1.</_>
+                <_>
+                  9 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.9727790970355272e-003</threshold>
+            <left_val>1.5688349306583405e-001</left_val>
+            <right_val>-7.9878687858581543e-002</right_val></_></_>
+        <_>
+          <!-- tree 36 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 1 3 -1.</_>
+                <_>
+                  3 13 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.7876989915966988e-003</threshold>
+            <left_val>-1.1298049986362457e-001</left_val>
+            <right_val>2.3814339935779572e-001</right_val></_></_>
+        <_>
+          <!-- tree 37 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 12 1 3 -1.</_>
+                <_>
+                  8 13 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.6815771125257015e-003</threshold>
+            <left_val>-6.3131898641586304e-002</left_val>
+            <right_val>1.7341490089893341e-001</right_val></_></_>
+        <_>
+          <!-- tree 38 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  3 12 1 3 -1.</_>
+                <_>
+                  3 13 1 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6932430444285274e-003</threshold>
+            <left_val>2.9134979844093323e-001</left_val>
+            <right_val>-9.7688913345336914e-002</right_val></_></_>
+        <_>
+          <!-- tree 39 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 3 3 6 -1.</_>
+                <_>
+                  10 5 1 2 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-2.1838879212737083e-002</threshold>
+            <left_val>2.2410179674625397e-001</left_val>
+            <right_val>-6.3271783292293549e-002</right_val></_></_>
+        <_>
+          <!-- tree 40 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 3 3 6 -1.</_>
+                <_>
+                  1 5 1 2 9.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.6455059200525284e-002</threshold>
+            <left_val>-6.6729080677032471e-001</left_val>
+            <right_val>4.1569691151380539e-002</right_val></_></_>
+        <_>
+          <!-- tree 41 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 4 6 16 -1.</_>
+                <_>
+                  6 12 6 8 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.4257268905639648e-001</threshold>
+            <left_val>-4.3775469064712524e-002</left_val>
+            <right_val>4.2250889539718628e-001</right_val></_></_>
+        <_>
+          <!-- tree 42 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 3 2 -1.</_>
+                <_>
+                  2 9 1 2 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-9.7134057432413101e-003</threshold>
+            <left_val>2.8876009583473206e-001</left_val>
+            <right_val>-1.0904739797115326e-001</right_val></_></_>
+        <_>
+          <!-- tree 43 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  8 5 2 6 -1.</_>
+                <_>
+                  9 5 1 3 2.</_>
+                <_>
+                  8 8 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.9520539790391922e-003</threshold>
+            <left_val>1.1463859677314758e-001</left_val>
+            <right_val>-1.0175020247697830e-001</right_val></_></_>
+        <_>
+          <!-- tree 44 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  2 5 2 6 -1.</_>
+                <_>
+                  2 5 1 3 2.</_>
+                <_>
+                  3 8 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8771419301629066e-002</threshold>
+            <left_val>6.2400698661804199e-001</left_val>
+            <right_val>-5.0913780927658081e-002</right_val></_></_>
+        <_>
+          <!-- tree 45 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 2 12 18 -1.</_>
+                <_>
+                  6 2 6 9 2.</_>
+                <_>
+                  0 11 6 9 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.5264939665794373e-001</threshold>
+            <left_val>-2.2805340588092804e-001</left_val>
+            <right_val>1.4274069666862488e-001</right_val></_></_>
+        <_>
+          <!-- tree 46 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 13 12 4 -1.</_>
+                <_>
+                  0 13 6 2 2.</_>
+                <_>
+                  6 15 6 2 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-7.8301310539245605e-002</threshold>
+            <left_val>-4.9581411480903625e-001</left_val>
+            <right_val>5.4817609488964081e-002</right_val></_></_>
+        <_>
+          <!-- tree 47 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  0 4 12 12 -1.</_>
+                <_>
+                  0 7 12 6 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.6115349531173706e-001</threshold>
+            <left_val>-5.7617807388305664e-001</left_val>
+            <right_val>4.2033191770315170e-002</right_val></_></_>
+        <_>
+          <!-- tree 48 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 14 3 6 -1.</_>
+                <_>
+                  5 14 1 6 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.3769039884209633e-002</threshold>
+            <left_val>4.6666219830513000e-002</left_val>
+            <right_val>-5.0551378726959229e-001</right_val></_></_>
+        <_>
+          <!-- tree 49 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 11 2 3 -1.</_>
+                <_>
+                  6 12 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-1.8329080194234848e-002</threshold>
+            <left_val>-7.9812979698181152e-001</left_val>
+            <right_val>-6.3357828184962273e-004</right_val></_></_>
+        <_>
+          <!-- tree 50 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 11 2 3 -1.</_>
+                <_>
+                  4 12 2 1 3.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.9759539067745209e-003</threshold>
+            <left_val>2.6330900192260742e-001</left_val>
+            <right_val>-1.0175059735774994e-001</right_val></_></_>
+        <_>
+          <!-- tree 51 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 9 10 2 -1.</_>
+                <_>
+                  6 9 5 1 2.</_>
+                <_>
+                  1 10 5 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.9660349935293198e-002</threshold>
+            <left_val>3.9909198880195618e-002</left_val>
+            <right_val>-6.7467451095581055e-001</right_val></_></_>
+        <_>
+          <!-- tree 52 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 3 3 6 -1.</_>
+                <_>
+                  4 5 3 2 3.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-8.9697521179914474e-003</threshold>
+            <left_val>5.5054008960723877e-002</left_val>
+            <right_val>-4.3380209803581238e-001</right_val></_></_>
+        <_>
+          <!-- tree 53 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  4 10 8 7 -1.</_>
+                <_>
+                  4 10 4 7 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>1.7052260041236877e-001</threshold>
+            <left_val>-8.9983023703098297e-002</left_val>
+            <right_val>1.5587039291858673e-001</right_val></_></_>
+        <_>
+          <!-- tree 54 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  6 7 6 4 -1.</_>
+                <_>
+                  6 7 3 4 2.</_></rects>
+              <tilted>1</tilted></feature>
+            <threshold>-6.7584879696369171e-002</threshold>
+            <left_val>1.8699319660663605e-001</left_val>
+            <right_val>-1.3449880480766296e-001</right_val></_></_>
+        <_>
+          <!-- tree 55 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  7 13 4 2 -1.</_>
+                <_>
+                  9 13 2 1 2.</_>
+                <_>
+                  7 14 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-4.9654832109808922e-003</threshold>
+            <left_val>2.1740439534187317e-001</left_val>
+            <right_val>-6.8494133651256561e-002</right_val></_></_>
+        <_>
+          <!-- tree 56 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 13 4 2 -1.</_>
+                <_>
+                  1 13 2 1 2.</_>
+                <_>
+                  3 14 2 1 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>-3.6419339012354612e-003</threshold>
+            <left_val>2.2659860551357269e-001</left_val>
+            <right_val>-1.1511819809675217e-001</right_val></_></_>
+        <_>
+          <!-- tree 57 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  9 8 2 3 -1.</_>
+                <_>
+                  9 8 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>3.0941639095544815e-002</threshold>
+            <left_val>9.5881456509232521e-003</left_val>
+            <right_val>-4.3764260411262512e-001</right_val></_></_>
+        <_>
+          <!-- tree 58 -->
+          <_>
+            <!-- root node -->
+            <feature>
+              <rects>
+                <_>
+                  1 8 2 3 -1.</_>
+                <_>
+                  2 8 1 3 2.</_></rects>
+              <tilted>0</tilted></feature>
+            <threshold>2.0714900456368923e-003</threshold>
+            <left_val>-6.9400407373905182e-002</left_val>
+            <right_val>3.5815268754959106e-001</right_val></_></_></trees>
+      <stage_threshold>-1.1971529722213745e+000</stage_threshold>
+      <parent>18</parent>
+      <next>-1</next></_></stages></classifier_RightEarA_trainNew2011_12_20>
+</opencv_storage>
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
index 6ad33cde09..4602135f39 100644
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -7,7 +7,7 @@ file(GLOB FILES_DOC_VS vidsurv/*.doc)
 file(GLOB FILES_TEX *.tex *.sty *.bib)
 file(GLOB FILES_TEX_PICS pics/*.png pics/*.jpg)
 
-if(BUILD_DOCS AND PDFLATEX_COMPILER AND HAVE_SPHINX)
+if(BUILD_DOCS AND HAVE_SPHINX)
 
 project(opencv_docs)
 
@@ -20,6 +20,7 @@ file(GLOB_RECURSE OPENCV_FILES_TUT_PICT tutorials/*.png tutorials/*.jpg)
 set(OPENCV_DOC_DEPS conf.py ${OPENCV_FILES_REF} ${OPENCV_FILES_REF_PICT}
           ${OPENCV_FILES_UG} ${OPENCV_FILES_TUT} ${OPENCV_FILES_TUT_PICT})
 
+if (PDFLATEX_COMPILER)
 add_custom_target(docs
                   ${SPHINX_BUILD}
                     -b latex -c ${CMAKE_CURRENT_SOURCE_DIR}
@@ -28,6 +29,7 @@ add_custom_target(docs
                     ${CMAKE_CURRENT_SOURCE_DIR}/pics ${CMAKE_CURRENT_BINARY_DIR}/doc/opencv1/pics
                   COMMAND ${CMAKE_COMMAND} -E copy_if_different
                     ${CMAKE_CURRENT_SOURCE_DIR}/mymath.sty ${CMAKE_CURRENT_BINARY_DIR}
+                  COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
                   COMMAND ${PDFLATEX_COMPILER} opencv2refman.tex
                   COMMAND ${PDFLATEX_COMPILER} opencv2refman.tex
                   COMMAND ${PDFLATEX_COMPILER} opencv_user.tex
@@ -37,6 +39,8 @@ add_custom_target(docs
                   DEPENDS ${OPENCV_DOC_DEPS}
                   WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                   COMMENT "Generating the PDF Manuals")
+                  
+endif()
 
 add_custom_target(html_docs
                 ${SPHINX_BUILD}
diff --git a/doc/_themes/blue/static/default.css_t b/doc/_themes/blue/static/default.css_t
index c5de392e22..56317cc69a 100644
--- a/doc/_themes/blue/static/default.css_t
+++ b/doc/_themes/blue/static/default.css_t
@@ -80,6 +80,7 @@ div.related a {
 }
 
 div.sphinxsidebar {
+    word-wrap: break-word;
     {%- if theme_stickysidebar|tobool %}
     top: 30px;
     margin: 0;
@@ -140,7 +141,7 @@ div.sphinxsidebar p.topless {
 }
 
 div.sphinxsidebar ul {
-    margin: 10px;
+    margin: 10px 0 10px 10px;
     padding: 0;
     color: {{ theme_sidebartextcolor }};
 }
@@ -261,15 +262,15 @@ pre {
 }
 
 tt {
-    color: {{ theme_headtext_color }}
-    background-color: #ecf0f3;
+    color: {{ theme_headtextcolor }};
+    /*background-color: #ecf0f3;*/
     padding: 0 1px 0 1px;
     font-size: 1.2em;
 }
 
 tt.descname {
-    color: {{ theme_headtext_color }}
-    background-color: #ecf0f3;
+    color: {{ theme_headtextcolor }};
+    /*background-color: #ecf0f3;*/
     padding: 0 1px 0 1px;
     font-size: 1.4em;
 }
@@ -283,7 +284,7 @@ dl.function > dt:first-child {
     margin-bottom: 7px;
 }
 
-dl.cfunction > dt:first-child {
+dl.c\:function > dt:first-child {
     margin-bottom: 7px;
     color: #8080B0;
 }
@@ -308,3 +309,57 @@ table.field-list {
 ul.simple {
     list-style: none;
 }
+
+em.menuselection, em.guilabel {
+    font-family: {{ theme_guifont }};
+}
+
+.enumeratevisibleitemswithsquare ul {
+list-style: square; 
+margin-bottom: 0px;
+margin-left: 0px;
+margin-right: 0px;
+margin-top: 0px;
+}
+
+.enumeratevisibleitemswithsquare li {
+margin-bottom: 0.2em;
+margin-left: 0px;
+margin-right: 0px;
+margin-top: 0.2em;
+ }
+ 
+ .enumeratevisibleitemswithsquare p {
+ margin-bottom: 0pt;
+ margin-top: 1pt;
+ }
+ 
+ .enumeratevisibleitemswithsquare dl{
+margin-bottom: 0px;
+margin-left: 0px;
+margin-right: 0px;
+margin-top: 0px;
+ }
+ 
+ .toctableopencv
+ {
+   width: 100% ; 
+   table-layout: fixed;
+ }
+ 
+
+  .toctableopencv colgroup col:first-child
+  {
+    width: 100pt !important;
+    max-width: 100pt !important;
+    min-width: 100pt !important;
+  }
+  
+  .toctableopencv colgroup col:nth-child(2) 
+  {
+    width: 100% !important;
+  }
+  
+div.body ul.search li {
+    text-align: left;
+}
diff --git a/doc/_themes/blue/theme.conf b/doc/_themes/blue/theme.conf
index b9691ffd39..206193f6f2 100644
--- a/doc/_themes/blue/theme.conf
+++ b/doc/_themes/blue/theme.conf
@@ -6,7 +6,6 @@ pygments_style = sphinx
 [options]
 rightsidebar = false
 stickysidebar = false
-
 footerbgcolor    = #004068
 footertextcolor  = #ffffff
 sidebarbgcolor   = #006090
@@ -26,7 +25,7 @@ codetextcolor    = #333333
 feedbackbgcolor  = #004068
 feedbacktextcolor = #ffffff
 feedbacklinkcolor = #ffffff
-
 bodyfont = sans-serif
 headfont = 'Trebuchet MS', sans-serif
-lang = none
+guifont = "Lucida Sans","Lucida Sans Unicode","Lucida Grande",Verdana,Arial,Helvetica,sans-serif
+lang = none
\ No newline at end of file
diff --git a/doc/check_docs_whitelist.txt b/doc/check_docs_whitelist.txt
index c36edd582b..8359178b96 100644
--- a/doc/check_docs_whitelist.txt
+++ b/doc/check_docs_whitelist.txt
@@ -37,6 +37,108 @@ cv::BOWTrainer::BOWTrainer
 cv::BOWTrainer::clear
 cv::AdjusterAdapter::clone
 
+cv::MSER::MSER
+cv::StarDetector::StarDetector
+cv::SIFT::CommonParams::CommonParams
+cv::SIFT::SIFT
+cv::SURF::SURF
+cv::SimpleBlobDetector::Params::Params
+
+cv::FastFeatureDetector::read
+cv::MserFeatureDetector::read
+cv::StarFeatureDetector::read
+cv::SurfFeatureDetector::read
+cv::SiftFeatureDetector::read
+cv::GoodFeaturesToTrackDetector::read
+cv::OrbFeatureDetector::read
+
+cv::FastFeatureDetector::write
+cv::MserFeatureDetector::write
+cv::StarFeatureDetector::write
+cv::SurfFeatureDetector::write
+cv::SiftFeatureDetector::write
+cv::GoodFeaturesToTrackDetector::write
+cv::OrbFeatureDetector::write
+
+cv::DynamicAdaptedFeatureDetector::empty
+cv::GridAdaptedFeatureDetector::empty
+cv::PyramidAdaptedFeatureDetector::empty
+
+cv::BriefDescriptorExtractor::descriptorSize
+cv::SurfDescriptorExtractor::descriptorSize
+cv::SiftDescriptorExtractor::descriptorSize
+cv::OpponentColorDescriptorExtractor::descriptorSize
+cv::OrbDescriptorExtractor::descriptorSize
+
+cv::BriefDescriptorExtractor::descriptorType
+cv::SurfDescriptorExtractor::descriptorType
+cv::SiftDescriptorExtractor::descriptorType
+cv::OpponentColorDescriptorExtractor::descriptorType
+cv::OrbDescriptorExtractor::descriptorType
+
+cv::SurfDescriptorExtractor::read
+cv::SiftDescriptorExtractor::read
+cv::OpponentColorDescriptorExtractor::read
+cv::OrbDescriptorExtractor::read
+
+cv::SurfDescriptorExtractor::write
+cv::SiftDescriptorExtractor::write
+cv::OpponentColorDescriptorExtractor::write
+cv::OrbDescriptorExtractor::write
+
+cv::OpponentColorDescriptorExtractor::empty
+
+cv::FlannBasedMatcher::train
+
+cv::FlannBasedMatcher::clear
+
+cv::FlannBasedMatcher::clone
+
+cv::FlannBasedMatcher::isMaskSupported
+
+
+cv::GenericDescriptorMatcher::GenericDescriptorMatcher
+
+cv::VectorDescriptorMatcher::clear
+cv::FernDescriptorMatcher::clear
+cv::OneWayDescriptorMatcher::clear
+
+cv::VectorDescriptorMatcher::empty
+cv::FernDescriptorMatcher::empty
+cv::OneWayDescriptorMatcher::empty
+
+cv::OneWayDescriptorMatcher::read
+
+cv::VectorDescriptorMatcher::isMaskSupported
+cv::FernDescriptorMatcher::isMaskSupported
+cv::OneWayDescriptorMatcher::isMaskSupported
+
+cv::VectorDescriptorMatcher::train
+cv::FernDescriptorMatcher::train
+cv::OneWayDescriptorMatcher::train
+
+cv::VectorDescriptorMatcher::read
+cv::FernDescriptorMatcher::read
+
+cv::VectorDescriptorMatcher::write
+cv::FernDescriptorMatcher::write
+cv::OneWayDescriptorMatcher::write
+
+
+
+cv::FastAdjuster::good
+cv::StarAdjuster::good
+cv::SurfAdjuster::good
+cv::FastAdjuster::tooFew
+cv::StarAdjuster::tooFew
+cv::SurfAdjuster::tooFew
+cv::FastAdjuster::tooMany
+cv::StarAdjuster::tooMany
+cv::SurfAdjuster::tooMany
+cv::FastAdjuster::clone
+cv::StarAdjuster::clone
+cv::SurfAdjuster::clone
+
 ######################################## calib3d ###################################
 CvLevMarq
 Mat cv::findFundamentalMat( InputArray points1, InputArray points2, OutputArray mask, int method=FM_RANSAC, double param1=3., double param2=0.99)
diff --git a/doc/conf.py b/doc/conf.py
index 94207bdd4c..a195d4727c 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -25,7 +25,7 @@ sys.path.insert(0, os.path.abspath('.'))
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks', 'ocv']
+extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks', 'ocv', 'sphinx.ext.doctest']
 doctest_test_doctest_blocks = 'block'
 
 # Add any paths that contain templates here, relative to this directory.
@@ -65,7 +65,7 @@ release = '2.3'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = []
+exclude_patterns = ['doc/tutorials/definitions']
 
 # The reST default role (used for this markup: `text`) to use for all documents.
 #default_role = None
@@ -168,9 +168,9 @@ html_use_index = True
 # Output file base name for HTML help builder.
 htmlhelp_basename = 'opencv'
 
-# OpenCV docs use some custom LaTeX macros in the formulae. Make sure we include the definitions
+# OpenCV docs use some custom LaTeX macros in the formula. Make sure we include the definitions
 pngmath_latex_preamble = r"""
-\usepackage{euler}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}
+\usepackage{euler}\usepackage[usenames,dvipsnames]{color}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}\usepackage{colortbl}
 \newcommand{\matTT}[9]{
 \[
 \left|\begin{array}{ccc}
@@ -235,6 +235,9 @@ preamble ="""
 \usepackage{euler}
 \usepackage[scaled=0.85]{beramono}
 \usepackage{mymath}\usepackage{amssymb}\usepackage{amsmath}\usepackage{bbm}\setcounter{secnumdepth}{1}
+\usepackage{colortbl}
+\usepackage{enumitem}
+\setlist{labelsep=1ex}
 """
 
 latex_elements = {'preamble': preamble}
@@ -294,12 +297,68 @@ extlinks = {'cvt_color': ('http://opencv.willowgarage.com/documentation/cpp/imgp
             'rng': ('http://opencv.willowgarage.com/documentation/cpp/core_operations_on_arrays.html?#rng%s', None),
             'put_text': ('http://opencv.willowgarage.com/documentation/cpp/core_drawing_functions.html?#putText%s', None),
             'gaussian_blur': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-gaussianblur%s', None),
-	    'blur': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-blur%s', None),
+            'blur': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-blur%s', None),
             'median_blur': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-medianblur%s', None), 
             'bilateral_filter': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-bilateralfilter%s', None),
-	    'erode': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html#cv-erode%s', None),
+            'erode': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html#cv-erode%s', None),
             'dilate': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html#cv-dilate%s', None),
-            'get_structuring_element': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html#cv-getstructuringelement%s', None)
+            'get_structuring_element': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html#cv-getstructuringelement%s', None),
+            'flood_fill': ( 'http://opencv.jp/opencv-2.2_org/cpp/imgproc_miscellaneous_image_transformations.html?#floodFill%s', None),
+            'morphology_ex': ('http://opencv.jp/opencv-2.2_org/cpp/imgproc_image_filtering.html?highlight=morphology#morphologyEx%s', None),
+            'pyr_down': ('http://opencv.willowgarage.com/documentation/cpp/imgproc_image_filtering.html#cv-pyrdown%s', None),
+            'pyr_up': ('http://opencv.willowgarage.com/documentation/cpp/imgproc_image_filtering.html#cv-pyrup%s', None),
+            'resize': ('http://opencv.willowgarage.com/documentation/cpp/imgproc_geometric_image_transformations.html#cv-resize%s', None),
+            'threshold': ('http://opencv.willowgarage.com/documentation/cpp/miscellaneous_image_transformations.html#cv-threshold%s', None),
+            'filter2d': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-filter2d%s', None),
+            'copy_make_border': ('http://opencv.willowgarage.com/documentation/cpp/imgproc_image_filtering.html?#copyMakeBorder%s', None),
+            'sobel': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-sobel%s', None),
+             'scharr': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-scharr%s', None),
+            'laplacian': ('http://opencv.willowgarage.com/documentation/cpp/image_filtering.html#cv-laplacian%s', None),
+            'canny': ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#Canny%s', None),
+            'copy_to': ('http://opencv.willowgarage.com/documentation/cpp/core_basic_structures.html?#Mat::copyTo%s', None), 	
+            'opencv_group' : ('http://tech.groups.yahoo.com/group/OpenCV/%s', None),
+            'hough_lines' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-houghlines%s', None),
+            'hough_lines_p' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-houghlinesp%s', None),
+            'hough_circles' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-houghcircles%s', None),
+            'remap' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_geometric_image_transformations.html?#remap%s', None),
+            'warp_affine' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_geometric_image_transformations.html?#cv-warpaffine%s' , None),
+            'get_rotation_matrix_2d' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_geometric_image_transformations.html?#cv-getrotationmatrix2d%s', None),
+            'get_affine_transform' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_geometric_image_transformations.html?#cv-getaffinetransform%s', None),
+            'equalize_hist' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_histograms.html?#equalizeHist%s', None),
+            'split' : ('http://opencv.willowgarage.com/documentation/cpp/core_operations_on_arrays.html?#split%s', None),
+            'calc_hist' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_histograms.html?#calcHist%s', None),
+            'normalize' : ('http://opencv.willowgarage.com/documentation/cpp/core_operations_on_arrays.html?#normalize%s', None),
+            'match_template' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_object_detection.html?#matchTemplate%s', None),
+            'min_max_loc' : ('http://opencv.willowgarage.com/documentation/cpp/core_operations_on_arrays.html?#minMaxLoc%s', None),
+            'mix_channels' : ( 'http://opencv.willowgarage.com/documentation/cpp/core_operations_on_arrays.html?#mixChannels%s', None),
+            'calc_back_project' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_histograms.html?#calcBackProject%s', None),
+            'compare_hist' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_histograms.html?#compareHist%s', None),
+            'corner_harris' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cornerHarris%s', None),
+            'good_features_to_track' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-goodfeaturestotrack%s', None),
+            'corner_min_eigenval' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-cornermineigenval%s', None), 
+            'corner_eigenvals_and_vecs' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-cornereigenvalsandvecs%s', None), 
+            'corner_sub_pix' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_feature_detection.html?#cv-cornersubpix%s', None),
+            'find_contours' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-findcontours%s', None), 
+            'convex_hull' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-convexhull%s', None),
+            'draw_contours' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-drawcontours%s', None),
+            'bounding_rect' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-boundingrect%s', None),
+            'min_enclosing_circle' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-minenclosingcircle%s', None),
+            'min_area_rect' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-minarearect%s', None),
+            'fit_ellipse' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-fitellipse%s', None),
+            'moments' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-moments%s', None),
+            'contour_area' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-contourarea%s', None),
+            'arc_length' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-arclength%s', None),
+            'basicstructures' : ('http://opencv.itseez.com/modules/core/doc/basic_structures.html#%s', None),
+            'oldbasicstructures' : ('http://opencv.itseez.com/modules/core/doc/old_basic_structures.html#%s', None),
+            'readwriteimagevideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'operationsonarrays' : ('http://opencv.itseez.com/modules/core/doc/operations_on_arrays.html#%s', None),
+            'utilitysystemfunctions':('http://opencv.itseez.com/modules/core/doc/utility_and_system_functions_and_macros.html#%s', None),
+            'imgprocfilter':('http://opencv.itseez.com/modules/imgproc/doc/filtering.html#%s', None),
+            'svms':('http://opencv.itseez.com/modules/ml/doc/support_vector_machines.html#%s', None),
+            'xmlymlpers':('http://opencv.itseez.com/modules/core/doc/xml_yaml_persistence.html#%s', None),
+			'huivideo' : ('http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'filtering':('http://opencv.itseez.com/modules/imgproc/doc/filtering.html#%s', None),
+            'point_polygon_test' : ('http://opencv.willowgarage.com/documentation/cpp/imgproc_structural_analysis_and_shape_descriptors.html#cv-pointpolygontest%s', None)
            }
 
 
diff --git a/doc/license.txt b/doc/license.txt
index b1a443a744..af0330790c 100644
--- a/doc/license.txt
+++ b/doc/license.txt
@@ -15,10 +15,10 @@ 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,
+  * Redistributions 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,
+  * Redistributions in binary form must reproduce the above copyright notice,
     this list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
diff --git a/doc/ocv.py b/doc/ocv.py
index 566bda7df1..a2f026630a 100644
--- a/doc/ocv.py
+++ b/doc/ocv.py
@@ -215,7 +215,7 @@ class OCVPyObject(ObjectDescription):
             signode['ids'].append(fullname)
             signode['first'] = (not self.names)
             self.state.document.note_explicit_target(signode)
-            objects = self.env.domaindata['py']['objects']
+            objects = self.env.domaindata['ocv']['objects']
             if fullname in objects:
                 self.env.warn(
                     self.env.docname,
@@ -224,7 +224,7 @@ class OCVPyObject(ObjectDescription):
                     self.env.doc2path(objects[fullname][0]) +
                     ', use :noindex: for one of them',
                     self.lineno)
-            objects[fullname] = (self.env.docname, self.objtype)
+            objects.setdefault(fullname, (self.env.docname, self.objtype, name_cls[0]))
 
         indextext = self.get_index_text(modname, name_cls)
         if indextext:
@@ -669,7 +669,7 @@ class FuncDefExpr(NamedDefExpr):
                 u'.'.join(x.get_id() for x in self.signature) or u'',
             self.const and u'C' or u''
         )
-
+    
     def __unicode__(self):
         buf = self.get_modifiers()
         if self.explicit:
@@ -864,6 +864,13 @@ class DefinitionParser(object):
 
     def _parse_type_expr(self):
         typename = self._parse_name()
+        if typename and self.skip_string('['):
+            typename.name += '['
+            if self.match(re.compile(r'\d*')):
+                typename.name += self.last_match.group(0)
+            typename.name += ']'
+            if not self.skip_string(']'):
+                self.fail('expected type')
         self.skip_ws()
         if not self.skip_string('<'):
             return typename
@@ -1126,7 +1133,11 @@ class OCVObject(ObjectDescription):
             node += nodes.Text(' ')
 
     def add_target_and_index(self, sigobj, sig, signode):
-        theid = sigobj.get_id()
+        theid = sig#obj.get_id()
+        theid = re.sub(r" +", " ", theid)
+        theid = re.sub(r"=[^,()]+\([^)]*?\)[^,)]*(,|\))", "\\1", theid)
+        theid = re.sub(r"=[^,)]+(,|\))", "\\1", theid)
+        theid = theid.replace("( ", "(").replace(" )", ")")
         name = unicode(sigobj.name)
         if theid not in self.state.document.ids:
             signode['names'].append(theid)
@@ -1134,7 +1145,9 @@ class OCVObject(ObjectDescription):
             signode['first'] = (not self.names)
             self.state.document.note_explicit_target(signode)
 
-            self.env.domaindata['ocv']['objects'].setdefault(name,
+            #self.env.domaindata['ocv']['objects'].setdefault(name,
+                #(self.env.docname, self.objtype, theid))
+            self.env.domaindata['ocv']['objects'].setdefault(theid,
                 (self.env.docname, self.objtype, theid))
 
         indextext = self.get_index_text(name)
@@ -1430,7 +1443,7 @@ class OCVDomain(Domain):
                 raise DefinitionError('')
         except DefinitionError:
             refdoc = node.get('refdoc', fromdocname)
-            env.warn(refdoc, 'unparseable C++ definition: %r' % target,
+            env.warn(refdoc, 'unparseable1 C++ definition: %r' % target,
                      node.line)
             return None
 
@@ -1451,6 +1464,26 @@ class OCVDomain(Domain):
     def get_objects(self):
         for refname, (docname, type, theid) in self.data['objects'].iteritems():
             yield (refname, refname, type, docname, refname, 1)
-
+            
+    def get_type_name(self, type, primary=False):
+        """
+        Return full name for given ObjType.
+        """
+        if primary:
+            return type.lname
+            
+        return {
+            'class':         _('C++ class'),
+            'struct':        _('C/C++ struct'),
+            'function':      _('C++ function'),
+            'cfunction':     _('C function'),
+            'jfunction':     _('Java method'),
+            'pyfunction':    _('Python function'),
+            'pyoldfunction': _('Legacy Python function'),
+            'member':        _('C++ member'),
+            'type':          _('C/C++ type'),
+            'namespace':     _('C++ namespace'),
+            }.get(type.lname, _('%s %s') % (self.label, type.lname))
+        
 def setup(app):
     app.add_domain(OCVDomain)
diff --git a/doc/opencv2refman.pdf b/doc/opencv2refman.pdf
index f9feff670c..6eb15ddae2 100644
Binary files a/doc/opencv2refman.pdf and b/doc/opencv2refman.pdf differ
diff --git a/doc/opencv_tutorials.pdf b/doc/opencv_tutorials.pdf
index 3c7ead2365..44d0d0e25e 100644
Binary files a/doc/opencv_tutorials.pdf and b/doc/opencv_tutorials.pdf differ
diff --git a/doc/opencv_user.pdf b/doc/opencv_user.pdf
index bbe5b7a7c2..d17a332564 100644
Binary files a/doc/opencv_user.pdf and b/doc/opencv_user.pdf differ
diff --git a/doc/patch_refman_latex.py b/doc/patch_refman_latex.py
new file mode 100644
index 0000000000..2691746845
--- /dev/null
+++ b/doc/patch_refman_latex.py
@@ -0,0 +1,22 @@
+import sys
+
+f=open(sys.argv[1], "rt")
+ll = list(f.readlines())
+f.close()
+f=open(sys.argv[1], "wt")
+singleparam = False
+
+for l in ll:
+    l = l.replace("\\code{~const}}{}", "}{\\code{~const}}")
+    if l.startswith("\\item[{Parameters}] \\leavevmode"):
+        if not l.startswith("\\item[{Parameters}] \\leavevmode\\begin{itemize}"):
+            singleparam = True
+        l = "\\item[{Parameters}] \\leavevmode\\begin{itemize}[label=]\n"
+        if singleparam:
+            l += "\\item {}\n"
+    elif singleparam and l.startswith("\\end{description}\\end{quote}"):
+        l = "\\end{itemize}\n" + l
+        singleparam = False
+    f.write(l)
+
+f.close()
diff --git a/doc/tutorials/calib3d/camera_calibration_square_chess/camera_calibration_square_chess.rst b/doc/tutorials/calib3d/camera_calibration_square_chess/camera_calibration_square_chess.rst
new file mode 100644
index 0000000000..601445ad1f
--- /dev/null
+++ b/doc/tutorials/calib3d/camera_calibration_square_chess/camera_calibration_square_chess.rst
@@ -0,0 +1,62 @@
+.. _CameraCalibrationSquareChessBoardTutorial:
+
+Camera calibration with square chessboard
+*****************************************
+
+.. highlight:: cpp
+
+The goal of this tutorial is to learn how to calibrate a camera given a set of chessboard images.
+
+*Test data*: use images in your data/chess folder. 
+
+#.
+    Compile opencv with samples by setting ``BUILD_EXAMPLES`` to ``ON`` in cmake configuration. 
+
+#.
+    Go to ``bin`` folder and use ``imagelist_creator`` to create an ``XML/YAML`` list of your images.
+    
+#.
+    Then, run ``calibration`` sample to get camera parameters. Use square size equal to 3cm. 
+
+Pose estimation
+===============
+
+Now, let us write a code that detects a chessboard in a new image and finds its distance from the camera. You can apply the same method to any object with known 3D geometry that you can detect in an image.
+
+*Test data*: use chess_test*.jpg images from your data folder.
+
+#.
+    Create an empty console project. Load a test image: ::
+
+        Mat img = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
+
+#.
+    Detect a chessboard in this image using findChessboard function. ::
+
+        bool found = findChessboardCorners( img, boardSize, ptvec, CV_CALIB_CB_ADAPTIVE_THRESH );
+
+#.
+    Now, write a function that generates a ``vector<Point3f>`` array of 3d coordinates of a chessboard in any coordinate system. For simplicity, let us choose a system such that one of the chessboard corners is in the origin and the board is in the plane *z = 0*.
+
+#.
+    Read camera parameters from XML/YAML file: ::
+
+        FileStorage fs(filename, FileStorage::READ);
+        Mat intrinsics, distortion;
+        fs["camera_matrix"] >> intrinsics;
+        fs["distortion_coefficients"] >> distortion;
+
+#.
+    Now we are ready to find chessboard pose by running ``solvePnP``: ::
+
+        vector<Point3f> boardPoints;
+        // fill the array
+        ...
+
+        solvePnP(Mat(boardPoints), Mat(foundBoardCorners), cameraMatrix,
+                             distCoeffs, rvec, tvec, false);
+
+#.
+    Calculate reprojection error like it is done in ``calibration`` sample (see ``opencv/samples/cpp/calibration.cpp``, function ``computeReprojectionErrors``). 
+
+Question: how to calculate the distance from the camera origin to any of the corners? 
\ No newline at end of file
diff --git a/doc/tutorials/calib3d/table_of_content_calib3d/images/camera_calibration_square_chess.jpg b/doc/tutorials/calib3d/table_of_content_calib3d/images/camera_calibration_square_chess.jpg
new file mode 100644
index 0000000000..1fcab0f83c
Binary files /dev/null and b/doc/tutorials/calib3d/table_of_content_calib3d/images/camera_calibration_square_chess.jpg differ
diff --git a/doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst b/doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst
index 45a43a41bd..ce5812ec2c 100644
--- a/doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst
+++ b/doc/tutorials/calib3d/table_of_content_calib3d/table_of_content_calib3d.rst
@@ -5,4 +5,32 @@
 
 Although we got most of our images in a 2D format they do come from a 3D world. Here you will learn how to find out from the 2D images information about the 3D world. 
 
-.. include:: ../../definitions/noContent.rst
+.. include:: ../../definitions/tocDefinitions.rst 
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |CameraCalSqChess|   **Title:** :ref:`CameraCalibrationSquareChessBoardTutorial`
+
+                        *Compatibility:* > OpenCV 2.0
+
+                        *Author:* |Author_VictorE|
+
+                        You will use some chessboard images to calibrate your camera.
+
+  ===================== ==============================================
+
+  .. |CameraCalSqChess| image:: images/camera_calibration_square_chess.jpg
+     :height: 90pt
+     :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../camera_calibration_square_chess/camera_calibration_square_chess
diff --git a/doc/tutorials/core/adding_images/adding_images.rst b/doc/tutorials/core/adding_images/adding_images.rst
index 701d5734a3..e37f4f7064 100644
--- a/doc/tutorials/core/adding_images/adding_images.rst
+++ b/doc/tutorials/core/adding_images/adding_images.rst
@@ -114,6 +114,6 @@ Explanation
 Result
 =======
 
-.. image:: images/Adding_Images_Tutorial_Result_0.png
+.. image:: images/Adding_Images_Tutorial_Result_0.jpg
    :alt: Blending Images Tutorial - Final Result
-   :align: center 
+   :align: center 
\ No newline at end of file
diff --git a/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.jpg b/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..f5c4526c44
Binary files /dev/null and b/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.png b/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.png
deleted file mode 100644
index 1f2a5bb37b..0000000000
Binary files a/doc/tutorials/core/adding_images/images/Adding_Images_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0.png b/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0.png
index 73a95301a6..29abc4a123 100644
Binary files a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0.png and b/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0.png differ
diff --git a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0a.png b/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0a.png
deleted file mode 100644
index dedf7ee8a3..0000000000
Binary files a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0a.png and /dev/null differ
diff --git a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0b.png b/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0b.png
deleted file mode 100644
index 649798c191..0000000000
Binary files a/doc/tutorials/core/basic_geometric_drawing/images/Drawing_1_Tutorial_Result_0b.png and /dev/null differ
diff --git a/doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst b/doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst
index 08e804d9c6..cb605d0ccc 100644
--- a/doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst
+++ b/doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst
@@ -8,13 +8,15 @@ Goal
 
 In this tutorial you will learn how to:
 
-* Access pixel values 
+.. container:: enumeratevisibleitemswithsquare
 
-* Initialize a matrix with zeros
+   + Access pixel values 
 
-* Learn what :saturate_cast:`saturate_cast <>` does and why it is useful
+   + Initialize a matrix with zeros
 
-* Get some cool info about pixel transformations
+   + Learn what :saturate_cast:`saturate_cast <>` does and why it is useful
+
+   + Get some cool info about pixel transformations
 
 Cool Theory
 =================
@@ -92,9 +94,10 @@ Code
        { for( int x = 0; x < image.cols; x++ )
             { for( int c = 0; c < 3; c++ )
                  {
-		  new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+         new_image.at<Vec3b>(y,x)[c] = 
+            saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
                 }
-	    }
+       }
        }
 
     /// Create Windows
@@ -145,8 +148,9 @@ Explanation
       for( int y = 0; y < image.rows; y++ )
          { for( int x = 0; x < image.cols; x++ )
               { for( int c = 0; c < 3; c++ )
-                   { new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta ); }
-	      }
+                   { new_image.at<Vec3b>(y,x)[c] = 
+                               saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta ); }
+         }
          }
  
    Notice the following:
@@ -185,7 +189,7 @@ Result
 
   .. code-block:: bash
 
-     $ ./BasicLinearTransforms lena.png
+     $ ./BasicLinearTransforms lena.jpg
      Basic Linear Transforms
      -------------------------
      * Enter the alpha value [1.0-3.0]: 2.2
@@ -193,7 +197,6 @@ Result
 
 * We get this:
 
-.. image:: images/Basic_Linear_Transform_Tutorial_Result_0.png
-   :height: 400px
+.. image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
    :alt: Basic Linear Transform - Final Result
-   :align: center 
+   :align: center 
\ No newline at end of file
diff --git a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.jpg b/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..527367cc92
Binary files /dev/null and b/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.png b/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.png
deleted file mode 100644
index bef4df653a..0000000000
Binary files a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_a.png b/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_a.png
deleted file mode 100644
index 978df3f668..0000000000
Binary files a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_a.png and /dev/null differ
diff --git a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_b.png b/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_b.png
deleted file mode 100644
index 904dc044d0..0000000000
Binary files a/doc/tutorials/core/basic_linear_transform/images/Basic_Linear_Transform_b.png and /dev/null differ
diff --git a/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst b/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst
new file mode 100644
index 0000000000..6bc6eaeea5
--- /dev/null
+++ b/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst
@@ -0,0 +1,143 @@
+.. _discretFourierTransform:
+
+Discrete Fourier Transform
+**************************
+
+Goal
+==== 
+
+We'll seek answers for the following questions: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + What is a Fourier transform and why use it? 
+   + How to do it in OpenCV? 
+   + Usage of functions such as: :imgprocfilter:`copyMakeBorder() <copymakeborder>`, :operationsonarrays:`merge() <merge>`, :operationsonarrays:`dft() <dft>`, :operationsonarrays:`getOptimalDFTSize() <getoptimaldftsize>`, :operationsonarrays:`log() <log>` and :operationsonarrays:`normalize() <normalize>` .
+
+Source code
+===========
+
+You can :download:`download this from here <../../../../samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp>` or find it in the :file:`samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp` of the OpenCV source code library. 
+
+Here's a sample usage of :operationsonarrays:`dft() <dft>` : 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 1-3, 5, 19-20, 23-78
+
+Explanation
+===========
+
+The Fourier Transform will decompose an image into its sinus and cosines components. In other words, it will transform an image from its spatial domain to its frequency domain. The idea is that any function may be approximated exactly with the sum of infinite sinus and cosines functions. The Fourier Transform is a way how to do this. Mathematically a two dimensional images Fourier transform is: 
+
+.. math::
+
+   F(k,l) = \displaystyle\sum\limits_{i=0}^{N-1}\sum\limits_{j=0}^{N-1} f(i,j)e^{-i2\pi(\frac{ki}{N}+\frac{lj}{N})} 
+
+   e^{ix} = \cos{x} + i\sin {x}
+
+Here f is the image value in its spatial domain and F in its frequency domain. The result of the transformation is complex numbers. Displaying this is possible either via a *real* image and a *complex* image or via a *magnitude* and a *phase* image. However, throughout the image processing algorithms only the *magnitude* image is interesting as this contains all the information we need about the images geometric structure. Nevertheless, if you intend to make some modifications of the image in these forms and then you need to retransform it you'll need to preserve both of these.
+
+In this sample I'll show how to calculate and show the *magnitude* image of a Fourier Transform. In case of digital images are discrete. This means they may take up a value from a given domain value. For example in a basic gray scale image values usually are between zero and 255. Therefore the Fourier Transform too needs to be of a discrete type resulting in a Discrete Fourier Transform (*DFT*). You'll want to use this whenever you need to determine the structure of an image from a geometrical point of view. Here are the steps to follow (in case of a gray scale input image *I*):
+
+1. **Expand the image to an optimal size**. The performance of a DFT is dependent of the image size. It tends to be the fastest for image sizes that are multiple of the numbers two, three and five. Therefore, to achieve maximal performance it is generally a good idea to pad border values to the image to get a size with such traits. The :operationsonarrays:`getOptimalDFTSize() <getoptimaldftsize>` returns this optimal size and we can use the :imgprocfilter:`copyMakeBorder() <copymakeborder>` function to expand the borders of an image:
+
+   .. code-block:: cpp 
+
+      Mat padded;                            //expand input image to optimal size
+      int m = getOptimalDFTSize( I.rows );
+      int n = getOptimalDFTSize( I.cols ); // on the border add zero pixels
+      copyMakeBorder(I, padded, 0, m - I.rows, 0, n - I.cols, BORDER_CONSTANT, Scalar::all(0));
+
+   The appended pixels are initialized with zero. 
+
+2. **Make place for both the complex and the real values**. The result of a Fourier Transform is complex. This implies that for each image value the result is two image values (one per component). Moreover, the frequency domains range is much larger than its spatial counterpart. Therefore, we store these usually at least in a *float* format. Therefore we'll convert our input image to this type and expand it with another channel to hold the complex values:
+
+   .. code-block:: cpp 
+
+       Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
+       Mat complexI;
+       merge(planes, 2, complexI);         // Add to the expanded another plane with zeros
+
+3. **Make the Discrete Fourier Transform**. It's possible an in-place calculation (same input as output): 
+
+   .. code-block:: cpp 
+
+      dft(complexI, complexI);            // this way the result may fit in the source matrix
+
+4. **Transform the real and complex values to magnitude**. A complex number has a real (*Re*) and a complex (imaginary - *Im*) part. The results of a DFT are complex numbers. The magnitude of a DFT is: 
+
+   .. math::
+
+      M = \sqrt[2]{ {Re(DFT(I))}^2 + {Im(DFT(I))}^2}
+
+   Translated to OpenCV code: 
+
+   .. code-block:: cpp 
+
+      split(complexI, planes);                   // planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
+      magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude  
+      Mat magI = planes[0];
+
+5. **Switch to a logarithmic scale**. It turns out that the dynamic range of the Fourier coefficients is too large to be displayed on the screen. We have some small and some high changing values that we can't observe like this. Therefore the high values will all turn out as white points, while the small ones as black. To use the gray scale values to for visualization we can transform our linear scale to a logarithmic one: 
+
+   .. math::
+
+      M_1 = \log{(1 + M)}
+
+   Translated to OpenCV code: 
+
+   .. code-block:: cpp 
+
+      magI += Scalar::all(1);                    // switch to logarithmic scale
+      log(magI, magI);
+
+6. **Crop and rearrange**. Remember, that at the first step, we expanded the image? Well, it's time to throw away the newly introduced values. For visualization purposes we may also rearrange the quadrants of the result, so that the origin (zero, zero) corresponds with the image center. 
+
+   .. code-block:: cpp 
+
+      magI = magI(Rect(0, 0, magI.cols & -2, magI.rows & -2));
+      int cx = magI.cols/2;
+      int cy = magI.rows/2;
+
+      Mat q0(magI, Rect(0, 0, cx, cy));   // Top-Left - Create a ROI per quadrant 
+      Mat q1(magI, Rect(cx, 0, cx, cy));  // Top-Right
+      Mat q2(magI, Rect(0, cy, cx, cy));  // Bottom-Left
+      Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right
+
+      Mat tmp;                           // swap quadrants (Top-Left with Bottom-Right)
+      q0.copyTo(tmp);
+      q3.copyTo(q0);
+      tmp.copyTo(q3);
+
+      q1.copyTo(tmp);                    // swap quadrant (Top-Right with Bottom-Left)
+      q2.copyTo(q1);
+      tmp.copyTo(q2);
+
+7.  **Normalize**. This is done again for visualization purposes. We now have the magnitudes, however this are still out of our image display range of zero to one. We normalize our values to this range using the :operationsonarrays:`normalize() <normalize>` function. 
+
+   .. code-block:: cpp 
+
+      normalize(magI, magI, 0, 1, CV_MINMAX); // Transform the matrix with float values into a 
+                                              // viewable image form (float between values 0 and 1).
+
+Result
+======
+
+An application idea would be to determine the geometrical orientation present in the image. For example, let us find out if a text is horizontal or not? Looking at some text you'll notice that the text lines sort of form also horizontal lines and the letters form sort of vertical lines. These two main components of a text snippet may be also seen in case of the Fourier transform. Let us use :download:`this horizontal <../../../../samples/cpp/tutorial_code/images/imageTextN.png>` and :download:`this rotated<../../../../samples/cpp/tutorial_code/images/imageTextR.png>` image about a text. 
+
+In case of the horizontal text: 
+
+.. image:: images/result_normal.jpg
+   :alt: In case of normal text
+   :align: center
+
+In case of a rotated text: 
+
+.. image:: images/result_rotated.jpg
+   :alt: In case of rotated text
+   :align: center
+
+You can see that the most influential components of the frequency domain (brightest dots on the magnitude image) follow the geometric rotation of objects on the image. From this we may calculate the offset and perform an image rotation to correct eventual miss alignments.
diff --git a/doc/tutorials/core/discrete_fourier_transform/images/result_normal.jpg b/doc/tutorials/core/discrete_fourier_transform/images/result_normal.jpg
new file mode 100644
index 0000000000..7e538f6b0b
Binary files /dev/null and b/doc/tutorials/core/discrete_fourier_transform/images/result_normal.jpg differ
diff --git a/doc/tutorials/core/discrete_fourier_transform/images/result_rotated.jpg b/doc/tutorials/core/discrete_fourier_transform/images/result_rotated.jpg
new file mode 100644
index 0000000000..9a6c28ee8f
Binary files /dev/null and b/doc/tutorials/core/discrete_fourier_transform/images/result_rotated.jpg differ
diff --git a/doc/tutorials/core/file_input_output_with_xml_yml/file_input_output_with_xml_yml.rst b/doc/tutorials/core/file_input_output_with_xml_yml/file_input_output_with_xml_yml.rst
new file mode 100644
index 0000000000..01ded5fd4d
--- /dev/null
+++ b/doc/tutorials/core/file_input_output_with_xml_yml/file_input_output_with_xml_yml.rst
@@ -0,0 +1,280 @@
+.. _fileInputOutputXMLYAML:
+
+File Input and Output using XML and YAML files
+**********************************************
+
+Goal
+==== 
+
+You'll find answers for the following questions: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + How to print and read text entries to a file and OpenCV using YAML or XML files?
+   + How to do the same for OpenCV data structures?
+   + How to do this for your data structures?
+   + Usage of OpenCV data structures such as :xmlymlpers:`FileStorage <filestorage>`, :xmlymlpers:`FileNode <filenode>` or :xmlymlpers:`FileNodeIterator <filenodeiterator>`.
+
+Source code
+===========
+
+You can :download:`download this from here <../../../../samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp>` or find it in the :file:`samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp` of the OpenCV source code library. 
+
+Here's a sample code of how to achieve all the stuff enumerated at the goal list.
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 1-7, 21-154
+
+Explanation
+===========
+
+Here we talk only about XML and YAML file inputs. Your output (and its respective input) file may have only one of these extensions and the structure coming from this. They are two kinds of data structures you may serialize: *mappings* (like the STL map) and *element sequence* (like the STL vector>. The difference between these is that in a map every element has a unique name through what you may access it. For sequences you need to go through them to query a specific item. 
+
+1. **XML\\YAML File Open and Close.** Before you write any content to such file you need to open it and at the end to close it. The XML\YAML data structure in OpenCV is :xmlymlpers:`FileStorage <filestorage>`. To specify that this structure to which file binds on your hard drive you can use either its constructor or the *open()* function of this: 
+
+   .. code-block:: cpp
+
+      string filename = "I.xml";
+      FileStorage fs(filename, FileStorage::WRITE);
+      \\...
+      fs.open(filename, FileStorage::READ);
+
+   Either one of this you use the second argument is a constant specifying the type of operations you'll be able to on them: WRITE, READ or APPEND. The extension specified in the file name also determinates the output format that will be used. The output may be even compressed if you specify an extension such as *.xml.gz*. 
+
+   The file automatically closes when the :xmlymlpers:`FileStorage <filestorage>` objects is destroyed. However, you may explicitly call for this by using the *release* function: 
+   
+   .. code-block:: cpp
+
+      fs.release();                                       // explicit close
+
+#. **Input and Output of text and numbers.** The data structure uses the same << output operator that the STL library. For outputting any type of data structure we need first to specify its name. We do this by just simply printing out the name of this. For basic types you may follow this with the print of the value : 
+
+   .. code-block:: cpp
+
+      fs << "iterationNr" << 100;
+
+   Reading in is a simple addressing (via the [] operator) and casting operation or a read via the >> operator : 
+
+   .. code-block:: cpp
+
+      int itNr; 
+      fs["iterationNr"] >> itNr;
+      itNr = (int) fs["iterationNr"];
+
+#. **Input\\Output of OpenCV Data structures.** Well these behave exactly just as the basic C++ types: 
+
+   .. code-block:: cpp
+
+      Mat R = Mat_<uchar >::eye  (3, 3),
+          T = Mat_<double>::zeros(3, 1);
+
+      fs << "R" << R;                                      // Write cv::Mat
+      fs << "T" << T;
+
+      fs["R"] >> R;                                      // Read cv::Mat
+      fs["T"] >> T;
+
+#. **Input\\Output of vectors (arrays) and associative maps.** As I mentioned beforehand we can output maps and sequences (array, vector) too. Again we first print the name of the variable and then we have to specify if our output is either a sequence or map. 
+
+   For sequence before the first element print the "[" character and after the last one the "]" character:
+
+   .. code-block:: cpp
+
+      fs << "strings" << "[";                              // text - string sequence
+      fs << "image1.jpg" << "Awesomeness" << "baboon.jpg";
+      fs << "]";                                           // close sequence
+
+   For maps the drill is the same however now we use the "{" and "}" delimiter characters:
+
+   .. code-block:: cpp
+
+        fs << "Mapping";                              // text - mapping
+        fs << "{" << "One" << 1;
+        fs <<        "Two" << 2 << "}";
+
+   To read from these we use the :xmlymlpers:`FileNode <filenode>` and the :xmlymlpers:`FileNodeIterator <filenodeiterator>` data structures. The [] operator of the :xmlymlpers:`FileStorage <filestorage>` class returns a :xmlymlpers:`FileNode <filenode>` data type. If the node is sequential we can use the :xmlymlpers:`FileNodeIterator <filenodeiterator>` to iterate through the items: 
+
+   .. code-block:: cpp
+
+      FileNode n = fs["strings"];                         // Read string sequence - Get node
+      if (n.type() != FileNode::SEQ)
+      {
+          cerr << "strings is not a sequence! FAIL" << endl;
+          return 1;
+      }
+
+      FileNodeIterator it = n.begin(), it_end = n.end(); // Go through the node
+      for (; it != it_end; ++it)
+          cout << (string)*it << endl;
+
+   For maps you can use the [] operator again to acces the given item (or the >> operator too):
+
+   .. code-block:: cpp
+
+      n = fs["Mapping"];                                // Read mappings from a sequence
+      cout << "Two  " << (int)(n["Two"]) << "; "; 
+      cout << "One  " << (int)(n["One"]) << endl << endl; 
+
+#. **Read and write your own data structures.** Suppose you have a data structure such as:
+
+   .. code-block:: cpp
+
+      class MyData
+      {
+      public:
+            MyData() : A(0), X(0), id() {}
+      public:   // Data Members
+         int A;
+         double X;
+         string id;
+      };
+
+   It's possible to serialize this through the OpenCV I/O XML/YAML interface (just as in case of the OpenCV data structures) by adding a read and a write function inside and outside of your class. For the inside part:
+
+   .. code-block:: cpp
+
+      void write(FileStorage& fs) const                        //Write serialization for this class
+      {
+        fs << "{" << "A" << A << "X" << X << "id" << id << "}";
+      }
+
+      void read(const FileNode& node)                          //Read serialization for this class
+      {
+        A = (int)node["A"];
+        X = (double)node["X"];
+        id = (string)node["id"];
+      }
+
+   Then you need to add the following functions definitions outside the class: 
+
+   .. code-block:: cpp
+
+      void write(FileStorage& fs, const std::string&, const MyData& x)
+      {
+      x.write(fs);
+      }
+
+      void read(const FileNode& node, MyData& x, const MyData& default_value = MyData())
+      {
+      if(node.empty())
+          x = default_value;
+      else
+          x.read(node);
+      }
+
+   Here you can observe that in the read section we defined what happens if the user tries to read a non-existing node. In this case we just return the default initialization value, however a more verbose solution would be to return for instance a minus one value for an object ID.
+
+   Once you added these four functions use the >> operator for write and the << operator for read:
+
+   .. code-block:: cpp
+
+      MyData m(1);
+      fs << "MyData" << m;                                // your own data structures
+      fs["MyData"] >> m;                                 // Read your own structure_
+
+   Or to try out reading a non-existing read: 
+
+   .. code-block:: cpp
+
+      fs["NonExisting"] >> m;   // Do not add a fs << "NonExisting" << m command for this to work 
+      cout << endl << "NonExisting = " << endl << m << endl;
+
+Result
+======
+
+Well mostly we just print out the defined numbers. On the screen of your console you could see: 
+
+.. code-block:: bash
+
+   Write Done.
+
+   Reading:
+   100image1.jpg
+   Awesomeness
+   baboon.jpg
+   Two  2; One  1
+
+
+   R = [1, 0, 0;
+     0, 1, 0;
+     0, 0, 1]
+   T = [0; 0; 0]
+
+   MyData =
+   { id = mydata1234, X = 3.14159, A = 97}
+
+   Attempt to read NonExisting (should initialize the data structure with its default).
+   NonExisting =
+   { id = , X = 0, A = 0}
+
+   Tip: Open up output.xml with a text editor to see the serialized data.
+
+Nevertheless, it's much more interesting what you may see in the output xml file: 
+
+.. code-block:: xml
+
+   <?xml version="1.0"?>
+   <opencv_storage>
+   <iterationNr>100</iterationNr>
+   <strings>
+     image1.jpg Awesomeness baboon.jpg</strings>
+   <Mapping>
+     <One>1</One>
+     <Two>2</Two></Mapping>
+   <R type_id="opencv-matrix">
+     <rows>3</rows>
+     <cols>3</cols>
+     <dt>u</dt>
+     <data>
+       1 0 0 0 1 0 0 0 1</data></R>
+   <T type_id="opencv-matrix">
+     <rows>3</rows>
+     <cols>1</cols>
+     <dt>d</dt>
+     <data>
+       0. 0. 0.</data></T>
+   <MyData>
+     <A>97</A>
+     <X>3.1415926535897931e+000</X>
+     <id>mydata1234</id></MyData>
+   </opencv_storage>
+
+Or the YAML file: 
+
+.. code-block:: yaml
+
+   %YAML:1.0
+   iterationNr: 100
+   strings:
+      - "image1.jpg"
+      - Awesomeness
+      - "baboon.jpg"
+   Mapping:
+      One: 1
+      Two: 2
+   R: !!opencv-matrix
+      rows: 3
+      cols: 3
+      dt: u
+      data: [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]
+   T: !!opencv-matrix
+      rows: 3
+      cols: 1
+      dt: d
+      data: [ 0., 0., 0. ]
+   MyData:
+      A: 97
+      X: 3.1415926535897931e+000
+      id: mydata1234
+
+You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=A4yqVnByMMM>`_ .
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="File Input and Output using XML and YAML files in OpenCV" width="560" height="349" src="http://www.youtube.com/embed/A4yqVnByMMM?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
+
diff --git a/doc/tutorials/core/how_to_scan_images/how_to_scan_images.rst b/doc/tutorials/core/how_to_scan_images/how_to_scan_images.rst
new file mode 100644
index 0000000000..11b0d6b24d
--- /dev/null
+++ b/doc/tutorials/core/how_to_scan_images/how_to_scan_images.rst
@@ -0,0 +1,183 @@
+.. _howToScanImagesOpenCV:
+
+How to scan images, lookup tables and time measurement with OpenCV
+*******************************************************************
+
+Goal
+==== 
+
+We'll seek answers for the following questions: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + How to go through each and every pixel of an image?
+   + How is OpenCV matrix values stored?
+   + How to measure the performance of our algorithm?
+   + What are lookup tables and why use them?
+
+Our test case
+=============
+
+Let us consider a simple color reduction method. Using the unsigned char C and C++ type for matrix item storing a channel of pixel may have up to 256 different values. For a three channel image this can allow the formation of way too many colors (16 million to be exact). Working with so many color shades may give a heavy blow to our algorithm performance. However, sometimes it is enough to work with a lot less of them to get the same final result. 
+
+In this cases it's common that we make a *color space reduction*. This means that we divide the color space current value with a new input value to end up with fewer colors. For instance every value between zero and nine takes the new value zero, every value between ten and nineteen the value ten and so on. 
+
+When you divide an *uchar* (unsigned char - aka values between zero and 255) value with an *int* value the result will be also *char*. These values may only be char values. Therefore, any fraction will be rounded down. Taking advantage of this fact the upper operation in the *uchar* domain may be expressed as: 
+
+.. math::
+
+   I_{new} = (\frac{I_{old}}{10}) * 10
+
+A simple color space reduction algorithm would consist of just passing through every pixel of an image matrix and applying this formula. It's worth noting that we do a divide and a multiplication operation. These operations are bloody expensive for a system. If possible it's worth avoiding them by using cheaper operations such as a few subtractions, addition or in best case a simple assignment. Furthermore, note that we only have a limited number of input values for the upper operation. In case of the *uchar* system this is 256 to be exact.
+
+Therefore, for larger images it would be wise to calculate all possible values beforehand and during the assignment just make the assignment, by using a lookup table. Lookup tables are simple arrays (having one or more dimensions) that for a given input value variation holds the final output value. Its strength lies that we do not need to make the calculation, we just need to read the result. 
+
+Our test case program (and the sample presented here) will do the following: read in a console line argument image (that may be either color or gray scale - console line argument too) and apply the reduction with the given console line argument integer value. In OpenCV, at the moment they are three major ways of going through an image pixel by pixel. To make things a little more interesting will make the scanning for each image using all of these methods, and print out how long it took. 
+
+You can download the full source code :download:`here <../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp>` or look it up in the samples directory of OpenCV at the cpp tutorial code for the core section. Its basic usage is: 
+
+.. code-block:: bash
+
+   how_to_scan_images imageName.jpg intValueToReduce [G]
+
+The final argument is optional. If given the image will be loaded in gray scale format, otherwise the RGB color way is used. The first thing is to calculate the lookup table.
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 48-60 
+
+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.
+
+Another issue is how do we measure time? Well OpenCV offers two simple functions to achieve this :UtilitySystemFunctions:`getTickCount() <gettickcount>` and :UtilitySystemFunctions:`getTickFrequency() <gettickfrequency>`. The first returns the number of ticks of your systems CPU from a certain event (like since you booted your system). The second returns how many times your CPU emits a tick during a second. So to measure in seconds the number of time elapsed between two operations is easy as: 
+
+.. code-block:: cpp
+
+   double t = (double)getTickCount();
+   // do something ...
+   t = ((double)getTickCount() - t)/getTickFrequency(); 
+   cout << "Times passed in seconds: " << t << endl;
+
+.. _How_Image_Stored_Memory: 
+
+How the image matrix is stored in the memory?
+=============================================
+
+As you could already read in my :ref:`matTheBasicImageContainer` tutorial the size of the matrix depends of the color system used. More accurately, it depends from the number of channels used. In case of a gray scale image we have something like: 
+
+.. math::
+
+   \newcommand{\tabItG}[1] { \textcolor{black}{#1} \cellcolor[gray]{0.8}}
+   \begin{tabular} {ccccc}
+   ~ & \multicolumn{1}{c}{Column 0} &   \multicolumn{1}{c}{Column 1} &   \multicolumn{1}{c}{Column ...} & \multicolumn{1}{c}{Column m}\\
+   Row 0 & \tabItG{0,0} & \tabItG{0,1} & \tabItG{...}  & \tabItG{0, m} \\
+   Row 1 & \tabItG{1,0} & \tabItG{1,1} & \tabItG{...}  & \tabItG{1, m} \\
+   Row ... & \tabItG{...,0} & \tabItG{...,1} & \tabItG{...} & \tabItG{..., m} \\
+   Row n & \tabItG{n,0} & \tabItG{n,1} & \tabItG{n,...} & \tabItG{n, m} \\
+   \end{tabular}
+
+For multichannel images the columns contain as many sub columns as the number of channels. For example in case of an RGB color system:
+
+.. math::
+
+   \newcommand{\tabIt}[1] { \textcolor{yellow}{#1} \cellcolor{blue} &  \textcolor{black}{#1} \cellcolor{green} & \textcolor{black}{#1} \cellcolor{red}}
+   \begin{tabular} {ccccccccccccc}
+   ~ & \multicolumn{3}{c}{Column 0} &   \multicolumn{3}{c}{Column 1} &   \multicolumn{3}{c}{Column ...} & \multicolumn{3}{c}{Column m}\\
+   Row 0 & \tabIt{0,0} & \tabIt{0,1} & \tabIt{...}  & \tabIt{0, m} \\
+   Row 1 & \tabIt{1,0} & \tabIt{1,1} & \tabIt{...}  & \tabIt{1, m} \\
+   Row ... & \tabIt{...,0} & \tabIt{...,1} & \tabIt{...} & \tabIt{..., m} \\
+   Row n & \tabIt{n,0} & \tabIt{n,1} & \tabIt{n,...} & \tabIt{n, m} \\
+   \end{tabular}
+
+Note that the order of the channels is inverse: BGR instead of RGB. Because in many cases the memory is large enough to store the rows in a successive fashion the rows may follow one after another, creating a single long row. Because everything is in a single place following one after another this may help to speed up the scanning process. We can use the :basicstructures:`isContinuous() <mat-iscontinuous>` function to *ask* the matrix if this is the case. Continue on to the next section to find an example.
+
+The efficient way
+=================
+
+When it comes to performance you cannot beat the classic C style operator[] (pointer) access. Therefore, the most efficient method we can recommend for making the assignment is: 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 116-143
+
+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. 
+
+There's another way of this. The *data* data member of a *Mat* object returns the pointer to the first row, first column. If this pointer is null you have no valid input in that object. Checking this is the simplest method to check if your image loading was a success. In case the storage is continues we can use this to go through the whole data pointer. In case of a gray scale image this would look like:
+
+.. code-block:: cpp
+
+   uchar* p = I.data;
+
+   for( unsigned int i =0; i < ncol*nrows; ++i)
+       *p++ = table[*p];
+
+You would get the same result. However, this code is a lot harder to read later on. It gets even harder if you have some more advanced technique there. Moreover, in practice I've observed you'll get the same performance result (as most of the modern compilers will probably make this small optimization trick automatically for you).
+
+The iterator (safe) method 
+==========================
+
+In case of the efficient way making sure that you pass through the right amount of *uchar* fields and to skip the gaps that may occur between the rows was your responsibility. The iterator method is considered a safer way as it takes over these tasks from the user. All you need to do is ask the begin and the end of the image matrix and then just increase the begin iterator until you reach the end. To acquire the value *pointed* by the iterator use the * operator (add it before it). 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 145-173
+
+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. 
+
+On-the-fly address calculation with reference returning
+=======================================================
+
+The final method isn't recommended for scanning. It was made to acquire or modify somehow random elements in the image. Its basic usage is to specify the row and column number of the item you want to access. During our earlier scanning methods you could already observe that is important through what type we are looking at the image. It's no different here as you need manually to specify what type to use at the automatic lookup. You can observe this in case of the gray scale images for the following source code (the usage of the + :basicstructures:`at() <mat-at>` function):
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 175-207
+
+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. 
+
+If you need to multiple lookups using this method for an image it may be troublesome and time consuming to enter the type and the at keyword for each of the accesses. To solve this problem OpenCV has a :basicstructures:`Mat_ <id3>` data type. It's the same as Mat with the extra need that at definition you need to specify the data type through what to look at the data matrix, however in return you can use the operator() for fast access of items. To make things even better this is easily convertible from and to the usual :basicstructures:`Mat <id3>` data type. A sample usage of this you can see in case of the color images of the upper function. Nevertheless, it's important to note that the same operation (with the same runtime speed) could have been done with the :basicstructures:`at() <mat-at>` function. It's just a less to write for the lazy programmer trick.
+
+The Core Function
+=================
+
+This is a bonus method of achieving lookup table modification in an image. Because in image processing it's quite common that you want to replace all of a given image value to some other value OpenCV has a function that makes the modification without the need from you to write the scanning of the image. We use the :operationsOnArrays:`LUT() <lut>` function of the core module. First we build a Mat type of the lookup table:
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 98-101
+
+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: 106
+
+Performance Difference
+======================
+
+For the best result compile the program and run it on your own speed. For showing off better the differences I've used a quite large (2560 X 1600) image. The performance presented here are for color images. For a more accurate value I've averaged the value I got from the call of the function for hundred times.
+
+============= ====================
+Efficient Way 79.4717 milliseconds
+
+Iterator      83.7201 milliseconds
+
+On-The-Fly RA 93.7878 milliseconds
+
+LUT function  32.5759 milliseconds
+============= ====================
+
+We can conclude a couple of things. If possible, use the already made functions of OpenCV (instead reinventing these). The fastest method turns out to be the LUT function. This is because the OpenCV library is multi-thread enabled via Intel Threaded Building Blocks. However, if you need to write a simple image scan prefer the pointer method. The iterator is a safer bet, however quite slower. Using the on-the-fly reference access method for full image scan is the most costly in debug mode. In the release mode it may beat the iterator approach or not, however it surely sacrifices for this the safety trait of iterators.
+
+Finally, you may watch a sample run of the program on the `video posted <https://www.youtube.com/watch?v=fB3AN5fjgwc>`_ on our YouTube channel.
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="How to scan images in OpenCV?" width="560" height="349" src="http://www.youtube.com/embed/fB3AN5fjgwc?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
diff --git a/doc/tutorials/core/interoperability_with_OpenCV_1/images/outputInteropOpenCV1.jpg b/doc/tutorials/core/interoperability_with_OpenCV_1/images/outputInteropOpenCV1.jpg
new file mode 100644
index 0000000000..b94b0ec927
Binary files /dev/null and b/doc/tutorials/core/interoperability_with_OpenCV_1/images/outputInteropOpenCV1.jpg differ
diff --git a/doc/tutorials/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.rst b/doc/tutorials/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.rst
new file mode 100644
index 0000000000..f1669f4aef
--- /dev/null
+++ b/doc/tutorials/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.rst
@@ -0,0 +1,132 @@
+.. _InteroperabilityWithOpenCV1:
+
+Interoperability with OpenCV 1
+******************************
+
+Goal
+====
+
+For the OpenCV developer team it's important to constantly improve the library. We are constantly thinking about methods that will ease your work process, while still maintain the libraries flexibility. The new C++ interface is a development of us that serves this goal. Nevertheless, backward compatibility remains important. We do not want to break your code written for earlier version of the OpenCV library. Therefore, we made sure that we add some functions that deal with this. In the following you'll learn: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + What changed with the version 2 of OpenCV in the way you use the library compared to its first version
+   + How to add some Gaussian noise to an image
+   + What are lookup tables and why use them?
+
+General
+=======
+
+When making the switch you first need to learn some about the new data structure for images: :ref:`matTheBasicImageContainer`, this replaces the old *CvMat* and *IplImage* ones. Switching to the new functions is easier. You just need to remember a couple of new things. 
+
+OpenCV 2 received reorganization. No longer are all the functions crammed into a single library. We have many modules, each of them containing data structures and functions relevant to certain tasks. This way you do not need to ship a large library if you use just a subset of OpenCV. This means that you should also include only those headers you will use. For example: 
+
+.. code-block:: cpp
+
+   #include <opencv2/core/core.hpp>
+   #include <opencv2/imgproc/imgproc.hpp>
+   #include <opencv2/highgui/highgui.hpp>
+
+
+All the OpenCV related stuff is put into the *cv* namespace to avoid name conflicts with other libraries data structures and functions. Therefore, either you need to prepend the *cv::* keyword before everything that comes from OpenCV or after the includes, you just add a directive to use this: 
+
+.. code-block:: cpp
+
+   using namespace cv;  // The new C++ interface API is inside this namespace. Import it.
+
+Because the functions are already in a namespace there is no need for them to contain the *cv* prefix in their name. As such all the new C++ compatible functions don't have this and they follow the camel case naming rule. This means the first letter is small (unless it's a name, like Canny) and the subsequent words start with a capital letter (like *copyMakeBorder*). 
+
+Now, remember that you need to link to your application all the modules you use, and in case you are on Windows using the *DLL* system you will need to add, again, to the path all the binaries. For more in-depth information if you're on Windows read :ref:`Windows_Visual_Studio_How_To` and for Linux an example usage is explained in :ref:`Linux_Eclipse_Usage`.
+
+Now for converting the *Mat* object you can use either the *IplImage* or the *CvMat* operators. While in the C interface you used to work with pointers here it's no longer the case. In the C++ interface we have mostly *Mat* objects. These objects may be freely converted to both *IplImage* and *CvMat* with simple assignment. For example:
+
+.. code-block:: cpp
+
+   Mat I; 
+   IplImage pI = I;
+   CvMat    mI = I;
+
+Now if you want pointers the conversion gets just a little more complicated. The compilers can no longer automatically determinate what you want and as you need to explicitly specify your goal. This is to call the *IplImage* and *CvMat* operators and then get their pointers. For getting the pointer we use the & sign:
+
+.. code-block:: cpp
+
+   Mat I; 
+   IplImage* pI     = &I.operator IplImage(); 
+   CvMat* mI        =  &I.operator CvMat(); 
+
+One of the biggest complaints of the C interface is that it leaves all the memory management to you. You need to figure out when it is safe to release your unused objects and make sure you do so before the program finishes or you could have troublesome memory leeks. To work around this issue in OpenCV there is introduced a sort of smart pointer. This will automatically release the object when it's no longer in use. To use this declare the pointers as a specialization of the *Ptr* :
+
+.. code-block:: cpp
+
+   Ptr<IplImage> piI = &I.operator IplImage();
+
+Converting from the C data structures to the *Mat* is done by passing these inside its constructor. For example: 
+
+.. code-block:: cpp
+
+   Mat K(piL), L; 
+   L = Mat(pI);
+
+A case study
+============
+
+Now that you have the basics done :download:`here's <../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp>` an example that mixes the usage of the C interface with the C++ one. You will also find it in the sample directory of the OpenCV source code library at the :file:`samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp` . To further help on seeing the difference the programs supports two modes: one mixed C and C++ and one pure C++. If you define the *DEMO_MIXED_API_USE* you'll end up using the first. The program separates the color planes, does some modifications on them and in the end merge them back together.
+
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 1-9, 22-25, 27-44
+
+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. 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 46-51
+
+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. 
+
+The scanning version looks like:
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 55-75
+
+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: 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 79-112
+
+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. 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 115-127
+
+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: 
+
+.. image:: images/outputInteropOpenCV1.jpg
+   :alt: The output of the sample
+   :align: center
+
+
+You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=qckm-zvo31w>`_ and you can :download:`download the source code from here <../../../../samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp>` or find it in the :file:`samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp` of the OpenCV source code library. 
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Interoperability with OpenCV 1" width="560" height="349" src="http://www.youtube.com/embed/qckm-zvo31w?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
+
+
+
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut1.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut1.png
new file mode 100644
index 0000000000..414fba4ac7
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut1.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut10.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut10.png
new file mode 100644
index 0000000000..425dde830c
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut10.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut11.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut11.png
new file mode 100644
index 0000000000..37db1db2bb
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut11.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut12.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut12.png
new file mode 100644
index 0000000000..765275374b
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut12.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut13.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut13.png
new file mode 100644
index 0000000000..95fece4626
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut13.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut14.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut14.png
new file mode 100644
index 0000000000..50bad2a77d
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut14.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut15.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut15.png
new file mode 100644
index 0000000000..08514cee48
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut15.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut16.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut16.png
new file mode 100644
index 0000000000..1420957136
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut16.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut2.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut2.png
new file mode 100644
index 0000000000..0efb6c61f9
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut2.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut3.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut3.png
new file mode 100644
index 0000000000..046705f08d
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut3.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut6.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut6.png
new file mode 100644
index 0000000000..8e1cf63721
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut6.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut7.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut7.png
new file mode 100644
index 0000000000..211595e7a3
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut7.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut8.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut8.png
new file mode 100644
index 0000000000..70c3eaa4e0
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut8.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut9.png b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut9.png
new file mode 100644
index 0000000000..674712566e
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicContainerOut9.png differ
diff --git a/doc/tutorials/core/mat - the basic image container/images/MatBasicImageForComputer.jpg b/doc/tutorials/core/mat - the basic image container/images/MatBasicImageForComputer.jpg
new file mode 100644
index 0000000000..0277296808
Binary files /dev/null and b/doc/tutorials/core/mat - the basic image container/images/MatBasicImageForComputer.jpg differ
diff --git a/doc/tutorials/core/mat - the basic image container/mat - the basic image container.rst b/doc/tutorials/core/mat - the basic image container/mat - the basic image container.rst
new file mode 100644
index 0000000000..b2d20e19ba
--- /dev/null
+++ b/doc/tutorials/core/mat - the basic image container/mat - the basic image container.rst	
@@ -0,0 +1,308 @@
+.. _matTheBasicImageContainer:
+
+Mat - The Basic Image Container
+*******************************
+
+Goal
+====
+
+We have multiple ways to acquire digital images from the real world: digital cameras, scanners, computed tomography or magnetic resonance imaging to just name a few. In every case what we (humans) see are images. However, when transforming this to our digital devices what we record are numerical values for each of the points of the image.
+
+.. image:: images/MatBasicImageForComputer.jpg
+   :alt: A matrix of the mirror of a car
+   :align: center
+
+For example in the above image you can see that the mirror of the care is nothing more than a matrix containing all the intensity values of the pixel points. Now, how we get and store the pixels values may vary according to what fits best our need, in the end all images inside a computer world may be reduced to numerical matrices and some other information's describing the matric itself. *OpenCV* is a computer vision library whose main focus is to process and manipulate these information to find out further ones. Therefore, the first thing you need to learn and get accommodated with is how OpenCV stores and handles images.
+
+*Mat*
+=====
+
+OpenCV has been around ever since 2001. In those days the library was built around a *C* interface. In those days to store the image in the memory they used a C structure entitled *IplImage*. This is the one you'll see in most of the older tutorials and educational materials. The problem with this is that it brings to the table all the minuses of the C language. The biggest issue is the manual management. It builds on the assumption that the user is responsible for taking care of memory allocation and deallocation. While this is no issue in case of smaller programs once your code base start to grove larger and larger it will be more and more a struggle to handle all this rather than focusing on actually solving your development goal.
+
+Luckily C++ came around and introduced the concept of classes making possible to build another road for the user: automatic memory management (more or less). The good news is that C++ if fully compatible with C so no compatibility issues can arise from making the change. Therefore, OpenCV with its 2.0 version introduced a new C++ interface that by taking advantage of these offers a new way of doing things. A way, in which you do not need to fiddle with memory management; making your code concise (less to write, to achieve more). The only main downside of the C++ interface is that many embedded development systems at the moment support only C. Therefore, unless you are targeting this platform, there's no point on using the *old* methods (unless you're a masochist programmer and you're asking for trouble). 
+
+The first thing you need to know about *Mat* is that you no longer need to manually allocate its size and release it as soon as you do not need it. While doing this is still a possibility, most of the OpenCV functions will allocate its output data manually. As a nice bonus if you pass on an already existing *Mat* object, what already has allocated the required space for the matrix, this will be reused. In other words we use at all times only as much memory as much we must to perform the task.
+
+*Mat* is basically a class having two data parts: the matrix header (containing information such as the size of the matrix, the method used for storing, at which address is the matrix stored and so on) and a pointer to the matrix containing the pixel values (may take any dimensionality depending on the method chosen for storing) . The matrix header size is constant. However, the size of the matrix itself may vary from image to image and usually is larger by order of magnitudes. Therefore, when you're passing on images in your program and at some point you need to create a copy of the image the big price you will need to build is for the matrix itself rather than its header. OpenCV is an image processing library. It contains a large collection of image processing functions. To solve a computational challenge most of the time you will end up using multiple functions of the library. Due to this passing on images to functions is a common practice. We should not forget that we are talking about image processing algorithms, which tend to be quite computational heavy. The last thing we want to do is to further decrease the speed of your program by making unnecessary copies of potentially *large* images.
+
+To tackle this issue OpenCV uses a reference counting system. The idea is that each *Mat* object has its own header, however the matrix may be shared between two instance of them by having their matrix pointer point to the same address. Moreover, the copy operators **will only copy the headers**, and as also copy the pointer to the large matrix too, however not the matrix itself. 
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat A, C;                                 // creates just the header parts
+   A = imread(argv[1], CV_LOAD_IMAGE_COLOR); // here we'll know the method used (allocate matrix)
+
+   Mat B(A);                                 // Use the copy constructor
+
+   C = A;                                    // Assignment operator
+
+All the above objects, in the end point to the same single data matrix. Their headers are different, however making any modification using either one of them will affect all the other ones too. In practice the different objects just provide different access method to the same underlying data. Nevertheless, their header parts are different. The real interesting part comes that you can create headers that refer only to a subsection of the full data. For example, to create a region of interest (*ROI*) in an image you just create a new header with the new boundaries: 
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat D (A, Rect(10, 10, 100, 100) ); // using a rectangle
+   Mat E = A(Range:all(), Range(1,3)); // using row and column boundaries 
+
+Now you may ask if the matrix itself may belong to multiple *Mat* objects who will take responsibility for its cleaning when it's no longer needed. The short answer is: the last object that used it. For this a reference counting mechanism is used. Whenever somebody copies a header of a *Mat* object a counter is increased for the matrix. Whenever a header is cleaned this counter is decreased. When the counter reaches zero the matrix too is freed. Because, sometimes you will still want to copy the matrix itself too, there exists the :basicstructures:`clone() <mat-clone>` or the :basicstructures:`copyTo() <mat-copyto>` function.
+
+.. code-block:: cpp
+   :linenos:
+
+   Mat F = A.clone(); 
+   Mat G; 
+   A.copyTo(G);
+
+Now modifying *F* or *G* will not affect the matrix pointed by the *Mat* header. What you need to remember from all this is that:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Output image allocation for OpenCV functions is automatic (unless specified otherwise).
+   * No need to think about memory freeing with OpenCVs C++ interface.
+   * The assignment operator and the copy constructor (*ctor*)copies only the header.
+   * Use the :basicstructures:`clone()<mat-clone>` or the :basicstructures:`copyTo() <mat-copyto>` function to copy the underlying matrix of an image.
+
+*Storing* methods
+================= 
+
+This is about how you store the pixel values. You can select the color space and the data type used. The color space refers to how we combine color components in order to code a given color. The simplest one is the gray scale. Here the colors at our disposal are black and white. The combination of these allows us to create many shades of gray. 
+
+For *colorful* ways we have a lot more of methods to choose from. However, every one of them breaks it down to three or four basic components and the combination of this will give all others. The most popular one of this is RGB, mainly because this is also how our eye builds up colors in our eyes. Its base colors are red, green and blue. To code the transparency of a color sometimes a fourth element: alpha (A) is added. 
+
+However, they are many color systems each with their own advantages:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * RGB is the most common as our eyes use something similar, our display systems also compose colors using these.
+   * The HSV and HLS decompose colors into their hue, saturation and value/luminance components, which is a more natural way for us to describe colors. Using you may for example dismiss the last component, making your algorithm less sensible to light conditions of the input image. 
+   * YCrCb is used by the popular JPEG image format. 
+   * CIE L*a*b* is a perceptually uniform color space, which comes handy if you need to measure the *distance* of a given color to another color.
+
+Now each of the building components has their own valid domains. This leads to the data type used. How we store a component defines just how fine control we have over its domain. The smallest data type possible is *char*, which means one byte or 8 bits. This may be signed (so can store values from 0 to 255) or unsigned (values from -127 to +127). Although in case of three components this already gives 16 million possible colors to represent (like in case of RGB) we may acquire an even finer control by using the float (4 byte = 32 bit) or double (8 byte = 64 bit) data types for each component. Nevertheless, remember that increasing the size of a component also increases the size of the whole picture in the memory. 
+
+Creating explicitly a *Mat* object
+==================================
+
+In the :ref:`Load_Save_Image` tutorial you could already see 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 achieve this via the << operator of *Mat*. However, be aware that this only works for two dimensional matrices. 
+
+Although *Mat* is a great class as 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:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + :basicstructures:`Mat() <mat-mat>` Constructor 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  27-28
+
+    .. image:: images/MatBasicContainerOut1.png
+       :alt: Demo image of the matrix output
+       :align: center
+
+    For two dimensional and multichannel images we first define their size: row and column count wise.
+
+    Then we need to specify the data type to use for storing the elements and the number of channels per matrix point. To do this we have multiple definitions made according to the following convention: 
+
+    .. code-block:: cpp
+
+       CV_[The number of bits per item][Signed or Unsigned][Type Prefix]C[The channel number]
+
+    For instance, *CV_8UC3* means we use unsigned char types that are 8 bit long and each pixel has three items of this to form the three channels. This are predefined for up to four channel numbers. The :basicstructures:`Scalar <scalar>` is four element short vector. Specify this and you can initialize all matrix points with a custom value. However if you need more you can create the type with the upper macro and putting the channel number in parenthesis as you can see below.
+
+   + Use C\\C++ arrays and initialize via constructor
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  35-36
+
+     The upper example shows how to create a matrix with more than two dimensions. Specify its dimension, then pass a pointer containing the size for each dimension and the rest remains the same.      
+
+
+   + Create a header for an already existing IplImage pointer:
+
+     .. code-block:: cpp
+
+        IplImage* img = cvLoadImage("greatwave.png", 1);
+        Mat mtx(img); // convert IplImage* -> Mat
+
+   + :basicstructures:`Create() <mat-create>` function:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  31-32
+
+    .. image:: images/MatBasicContainerOut2.png
+       :alt: Demo image of the matrix output
+       :align: center
+
+    You cannot initialize the matrix values with this construction. It will only reallocate its matrix data memory if the new size will not fit into the old one.
+
+   + MATLAB style initializer: :basicstructures:`zeros() <mat-zeros>`, :basicstructures:`ones() <mat-ones>`, ::basicstructures:`eyes() <mat-eye>`. Specify size and data type to use:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  40-47
+
+    .. image:: images/MatBasicContainerOut3.png
+       :alt: Demo image of the matrix output
+       :align: center
+
+   + For small matrices you may use comma separated initializers:
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  50-51
+
+    .. image:: images/MatBasicContainerOut6.png
+       :alt: Demo image of the matrix output
+       :align: center
+
+   + Create a new header for an existing *Mat* object and :basicstructures:`clone() <mat-clone>` or :basicstructures:`copyTo() <mat-copyto>` it.
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+        :language: cpp
+        :tab-width: 4
+        :lines:  53-54
+
+     .. image:: images/MatBasicContainerOut7.png
+        :alt: Demo image of the matrix output
+        :align: center
+
+Print out formatting
+====================
+
+.. note:: 
+
+   You can fill out a matrix with random values using the :operationsOnArrays:`randu() <randu>` function. You need to give the lover and upper value between what you want the random values:
+
+   .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+      :language: cpp
+      :tab-width: 4
+      :lines:  57-58
+
+In the above examples you could see the default formatting option. Nevertheless, OpenCV allows you to format your matrix output format to fit the rules of: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + Default 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 61
+
+     .. image:: images/MatBasicContainerOut8.png
+        :alt: Default Output
+        :align: center
+
+   + Python
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 62
+
+     .. image:: images/MatBasicContainerOut16.png
+        :alt: Default Output
+        :align: center
+
+   + Comma separated values (CSV) 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 64
+
+     .. image:: images/MatBasicContainerOut10.png
+        :alt: Default Output
+        :align: center
+
+   + Numpy
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 63
+
+     .. image:: images/MatBasicContainerOut9.png
+        :alt: Default Output
+        :align: center
+
+   + C
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 65
+
+     .. image:: images/MatBasicContainerOut11.png
+        :alt: Default Output
+        :align: center
+
+Print for other common items
+============================
+
+OpenCV offers support for print of other common OpenCV data structures too via the << operator like:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + 2D Point 
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 67-68
+
+     .. image:: images/MatBasicContainerOut12.png
+        :alt: Default Output
+        :align: center
+
+
+   + 3D Point
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 70-71
+
+     .. image:: images/MatBasicContainerOut13.png
+        :alt: Default Output
+        :align: center
+
+   + std::vector via cv::Mat
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 74-77
+
+     .. image:: images/MatBasicContainerOut14.png
+        :alt: Default Output
+        :align: center
+
+   + std::vector of points
+
+     .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
+       :language: cpp
+       :tab-width: 4
+       :lines: 79-83
+
+     .. image:: images/MatBasicContainerOut15.png
+        :alt: Default Output
+        :align: center
+
+Most of the samples here have been included into a small console application. You can download it from :download:`here <../../../../samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp>` or in the core section of the cpp samples.
+
+A quick video demonstration of this you can find on `YouTube <https://www.youtube.com/watch?v=1tibU7vGWpk>`_.
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Install OpenCV by using its source files - Part 1" width="560" height="349" src="http://www.youtube.com/embed/1tibU7vGWpk?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
diff --git a/doc/tutorials/core/mat-mask-operations/images/resultMatMaskFilter2D.png b/doc/tutorials/core/mat-mask-operations/images/resultMatMaskFilter2D.png
new file mode 100644
index 0000000000..cebbb4c33a
Binary files /dev/null and b/doc/tutorials/core/mat-mask-operations/images/resultMatMaskFilter2D.png differ
diff --git a/doc/tutorials/core/mat-mask-operations/mat-mask-operations.rst b/doc/tutorials/core/mat-mask-operations/mat-mask-operations.rst
new file mode 100644
index 0000000000..135a2e4fc9
--- /dev/null
+++ b/doc/tutorials/core/mat-mask-operations/mat-mask-operations.rst
@@ -0,0 +1,137 @@
+.. _maskOperationsFilter:
+
+Mask operations on matrices
+***************************
+
+Mask operations on matrices are quite simple. The idea is that we recalculate each pixels value in an image according to a mask matrix (also known as kernel). This mask holds values that will just how much influence have neighbor pixel values (and the pixel value itself) to the new pixel value. From a mathematical point of view we make a weighted average, with our specified values. 
+
+Our test case
+=============
+
+Let us consider the issue of an image contrast enhancement method. Basically we want to apply for every pixel of the image the following formula: 
+
+.. math::
+
+   I(i,j) = 5*I(i,j) - [ I(i-1,j) + I(i+1,j) + I(i,j-1) + I(i,j+1)] 
+
+   \iff I(i,j)*M, \text{where }
+   M = \bordermatrix{ _i\backslash ^j  & -1 &  0 & -1 \cr
+                        -1 &  0 & -1 &  0 \cr
+                         0 & -1 &  5 & -1 \cr
+                        +1 &  0 & -1 &  0 \cr
+                    }
+
+The first notation is by using a formula, while the second is a compacted version of the first by using a mask. You use the mask by putting the center of the mask matrix (in the upper case noted by the zero-zero index) on the pixel you want to calculate and sum up the pixel values multiplicity with the overlapped matrix values. It's the same thing, however in case of large matrices the later notation is a lot easier to look over. 
+
+Now let us see how we can make this happen by using the basic pixel access method or by using the :filtering:`filter2D <filter2d>` function. 
+
+The Basic Method
+================
+
+Here's a function that will do this: 
+
+.. code-block:: cpp
+
+   void Sharpen(const Mat& myImage,Mat& Result)
+   {
+       CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images
+
+       Result.create(myImage.size(),myImage.type());
+       const int nChannels = myImage.channels();
+
+       for(int j = 1 ; j < myImage.rows-1; ++j)
+       {
+           const uchar* previous = myImage.ptr<uchar>(j - 1);
+           const uchar* current  = myImage.ptr<uchar>(j    );
+           const uchar* next     = myImage.ptr<uchar>(j + 1);
+
+           uchar* output = Result.ptr<uchar>(j);
+
+           for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
+           {
+               *output++ = saturate_cast<uchar>(5*current[i] 
+                            -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
+           }
+       }
+
+       Result.row(0).setTo(Scalar(0));
+       Result.row(Result.rows-1).setTo(Scalar(0));
+       Result.col(0).setTo(Scalar(0));
+       Result.col(Result.cols-1).setTo(Scalar(0));
+   }
+
+At first we make sure that the input images data is in unsigned char format. For this we use the :utilitysystemfunctions:`CV_Assert <cv-assert>` function that throws an error when the expression inside it is false.
+
+.. code-block:: cpp
+
+   CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images
+
+We create an output image with the same size and the same type than our input. As you can see at the :ref:`How_Image_Stored_Memory` section, depending on the number of channels we may have one or more subcolumns. We will iterate through them via pointers so the total number of elements depends from this number.
+
+.. code-block:: cpp
+
+   Result.create(myImage.size(),myImage.type());
+   const int nChannels = myImage.channels();
+
+We'll use the plain C [] operator to access pixels. Because we need to access multiple rows at the same time we'll acquire the pointers for each of them (a previous, a current and a next line). We need another pointer to where we're going to save the calculation. Then simply access the right items with the [] operator. For moving the output pointer ahead we simply increase this (with one byte) after each operation:
+
+.. code-block:: cpp
+
+   for(int j = 1 ; j < myImage.rows-1; ++j)
+   {
+       const uchar* previous = myImage.ptr<uchar>(j - 1);
+       const uchar* current  = myImage.ptr<uchar>(j    );
+       const uchar* next     = myImage.ptr<uchar>(j + 1);
+
+       uchar* output = Result.ptr<uchar>(j);
+
+       for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
+       {
+           *output++ = saturate_cast<uchar>(5*current[i] 
+                        -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
+       }
+   }
+
+On the borders of the image the upper notation results inexistent pixel locations (like minus one - minus one). In these points our formula is undefined. A simple solution is to do not apply the mask in these points and, for example, maintain the images previous values by copying these values over to these locations:
+
+.. code-block:: cpp
+
+   Result.row(0).setTo(Scalar(0));             // The top row 
+   Result.row(Result.rows-1).setTo(Scalar(0)); // The left column
+   Result.col(0).setTo(Scalar(0));             // The right column
+   Result.col(Result.cols-1).setTo(Scalar(0)); // The bottom row
+
+The filter2D function
+=====================
+
+Applying such filters are so common in image processing that in OpenCV there exist a function that will take care of applying the mask (also called a kernel in some places). For this you first need to define a *Mat* object that holds the mask:
+
+.. code-block:: cpp
+
+   Mat kern = (Mat_<char>(3,3) <<  0, -1,  0, 
+                                  -1,  5, -1,
+                                   0, -1,  0);
+
+Then call the :filtering:`filter2D <filter2d>` function specifying the input, the output image and the kernell to use: 
+
+.. code-block:: cpp
+
+   filter2D(I, K, I.depth(), kern ); 
+
+The function even has a fifth optional argument to specify the center of the kernel, and a sixth one for determining what to do in the regions where the operation is undefined (borders). Using this function has the advantage that it's shorter, more verbose and that because they are some optimization techniques implemented usually faster than the *hand method*. For example in my while the first one took only 13 milliseconds the second took around 31 milliseconds. Quite some difference.
+
+For example: 
+
+.. image:: images/resultMatMaskFilter2D.png
+   :alt: A sample output of the program
+   :align: center
+
+You can download this source code from :download:`here <../../../../samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp>` or look in the OpenCV source code libraries sample directory at :file:`samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp`.
+
+Check out an instance of running the program on our `YouTube channel <http://www.youtube.com/watch?v=7PF1tAU9se4>`_ . 
+
+.. raw:: html
+
+  <div align="center">
+ <iframe width="560" height="349" src="https://www.youtube.com/embed/7PF1tAU9se4?hd=1" frameborder="0" allowfullscreen></iframe>
+  </div>
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.jpg b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..7c66c50d2f
Binary files /dev/null and b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.png
deleted file mode 100644
index 003f44d01d..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_1.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_1.png
deleted file mode 100644
index 0334503d6b..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_1.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.jpg b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.jpg
new file mode 100644
index 0000000000..81e9313ab2
Binary files /dev/null and b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.jpg differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.png
deleted file mode 100644
index 9287b20e1b..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_2.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.jpg b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.jpg
new file mode 100644
index 0000000000..20e274dcfc
Binary files /dev/null and b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.jpg differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.png
deleted file mode 100644
index 482c3bffa5..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_3.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_4.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_4.png
deleted file mode 100644
index e0e63812d9..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_4.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.jpg b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.jpg
new file mode 100644
index 0000000000..a540fb4259
Binary files /dev/null and b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.jpg differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.png
deleted file mode 100644
index b0482fddf4..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_5.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_6.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_6.png
deleted file mode 100644
index 40a079222f..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_6.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.jpg b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.jpg
new file mode 100644
index 0000000000..cc38466e23
Binary files /dev/null and b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.jpg differ
diff --git a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.png b/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.png
deleted file mode 100644
index b47a588811..0000000000
Binary files a/doc/tutorials/core/random_generator_and_text/images/Drawing_2_Tutorial_Result_7.png and /dev/null differ
diff --git a/doc/tutorials/core/random_generator_and_text/random_generator_and_text.rst b/doc/tutorials/core/random_generator_and_text/random_generator_and_text.rst
index fda9b04b04..fb487cab71 100644
--- a/doc/tutorials/core/random_generator_and_text/random_generator_and_text.rst
+++ b/doc/tutorials/core/random_generator_and_text/random_generator_and_text.rst
@@ -1,7 +1,7 @@
 .. _Drawing_2:
 
-Fancy Drawing!
-****************
+Random generator and text with OpenCV
+*************************************
 
 Goals
 ======
@@ -9,15 +9,15 @@ Goals
 In this tutorial you will learn how to:
 
 * Use the *Random Number generator class* (:rng:`RNG <>`) and how to get a random number from a uniform distribution.
-* Display Text on an OpenCV window by using the function :put_text:`putText <>`
+* Display text on an OpenCV window by using the function :put_text:`putText <>`
 
 Code
 =====
-* In the previous tutorial we drew diverse geometric figures, giving as input parameters such as coordinates (in the form of :point:`Points <>`), color, thickness, etc. You might have noticed that we gave specific values for these arguments.
+* In the previous tutorial (:ref:`Drawing_1`) we drew diverse geometric figures, giving as input parameters such as coordinates (in the form of :point:`Points <>`), color, thickness, etc. You might have noticed that we gave specific values for these arguments.
  
-* In this tutorial, we intend to use *random* values for the drawing parameters. Also, we intend to populate our image with a big number of geometric figures. Since we will be initializing them in a random fashion, this process will be automatic and made by using *loops*
+* In this tutorial, we intend to use *random* values for the drawing parameters. Also, we intend to populate our image with a big number of geometric figures. Since we will be initializing them in a random fashion, this process will be automatic and made by using *loops* .
 
-* This code is in your OpenCV sample folder. Otherwise you can grab it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Basic/Drawing_2.cpp>`_
+* This code is in your OpenCV sample folder. Otherwise you can grab it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Basic/Drawing_2.cpp>`_ .
 
 Explanation
 ============
@@ -81,27 +81,23 @@ Explanation
 
    .. code-block:: cpp
 
-      /**
-       * @function Drawing_Random_Lines
-       */
       int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
       {
         int lineType = 8;
         Point pt1, pt2;
 
-	for( int i = 0; i < NUMBER; i++ )
-  	{
-    	 pt1.x = rng.uniform( x_1, x_2 );
-    	 pt1.y = rng.uniform( y_1, y_2 );
-    	 pt2.x = rng.uniform( x_1, x_2 );
-    	 pt2.y = rng.uniform( y_1, y_2 );
+        for( int i = 0; i < NUMBER; i++ )
+        {
+         pt1.x = rng.uniform( x_1, x_2 );
+         pt1.y = rng.uniform( y_1, y_2 );
+         pt2.x = rng.uniform( x_1, x_2 );
+         pt2.y = rng.uniform( y_1, y_2 );
 
          line( image, pt1, pt2, randomColor(rng), rng.uniform(1, 10), 8 );
-    	 imshow( window_name, image );
+         imshow( window_name, image );
          if( waitKey( DELAY ) >= 0 )
-      	   { return -1; }
+         { return -1; }
         }
-
         return 0;
       }
 
@@ -122,18 +118,18 @@ Explanation
      * As another observation, we notice that in the :line:`line <>` arguments, for the *color* input we enter:
 
        .. code-block:: cpp
-	   
-	  randomColor(rng)           
-	   
+      
+          randomColor(rng)           
+      
        Let's check the function implementation:
 
        .. code-block:: cpp
 
-	  static Scalar randomColor( RNG& rng )
-          {
+          static Scalar randomColor( RNG& rng )
+            {
             int icolor = (unsigned) rng;
             return Scalar( icolor&255, (icolor>>8)&255, (icolor>>16)&255 );
-	  }
+            }
 
        As we can see, the return value is an *Scalar* with 3 randomly initialized values, which are used as the *R*, *G* and *B* parameters for the line color. Hence, the color of the lines will be random too!
 
@@ -192,21 +188,21 @@ Explanation
       int Displaying_Big_End( Mat image, char* window_name, RNG rng )
       {
         Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
-  	Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
-  	int lineType = 8;
+        Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
+        int lineType = 8;
     
-	Mat image2;
+        Mat image2;
 
-  	for( int i = 0; i < 255; i += 2 )
-  	{
-    	  image2 = image - Scalar::all(i);
-    	  putText( image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
-          	   Scalar(i, i, 255), 5, lineType );
+        for( int i = 0; i < 255; i += 2 )
+        {
+          image2 = image - Scalar::all(i);
+          putText( image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
+                 Scalar(i, i, 255), 5, lineType );
         
-    	  imshow( window_name, image2 );
-    	  if( waitKey(DELAY) >= 0 )
-       	  { return -1; }
-  	}
+          imshow( window_name, image2 );
+          if( waitKey(DELAY) >= 0 )
+            { return -1; }
+        }
 
         return 0;
       }
@@ -229,57 +225,36 @@ As you just saw in the Code section, the program will sequentially execute diver
 
 #. First a random set of *NUMBER* lines will appear on screen such as it can be seen in this screenshot:
 
-   .. image:: images/Drawing_2_Tutorial_Result_0.png
-      :height: 300px
+   .. image:: images/Drawing_2_Tutorial_Result_0.jpg
       :alt: Drawing Tutorial 2 - Final Result 0
       :align: center 
 
-#. Then, a new set of figures, these time *rectangles* will follow:
-
-   .. image:: images/Drawing_2_Tutorial_Result_1.png
-      :height: 300px
-      :alt: Drawing Tutorial 2 - Final Result 1
-      :align: center 
+#. Then, a new set of figures, these time *rectangles* will follow.
 
 #. Now some ellipses will appear, each of them with random position, size, thickness and arc length:
 
-   .. image:: images/Drawing_2_Tutorial_Result_2.png
-      :height: 300px
+   .. image:: images/Drawing_2_Tutorial_Result_2.jpg
       :alt: Drawing Tutorial 2 - Final Result 2
       :align: center 
 
 #. Now, *polylines* with 03 segments will appear on screen, again in random configurations.
 
-   .. image:: images/Drawing_2_Tutorial_Result_3.png
-      :height: 300px
+   .. image:: images/Drawing_2_Tutorial_Result_3.jpg
       :alt: Drawing Tutorial 2 - Final Result 3
       :align: center 
 
-#. Filled polygons (in this example triangles) will follow:
-
-   .. image:: images/Drawing_2_Tutorial_Result_4.png
-      :height: 300px
-      :alt: Drawing Tutorial 2 - Final Result 4
-      :align: center 
+#. Filled polygons (in this example triangles) will follow.
 
 #. The last geometric figure to appear: circles!
 
-   .. image:: images/Drawing_2_Tutorial_Result_5.png
-      :height: 300px
+   .. image:: images/Drawing_2_Tutorial_Result_5.jpg
       :alt: Drawing Tutorial 2 - Final Result 5
       :align: center 
 
 #. Near the end, the text *"Testing Text Rendering"* will appear in a variety of fonts, sizes, colors and positions.
 
-   .. image:: images/Drawing_2_Tutorial_Result_6.png
-      :height: 300px
-      :alt: Drawing Tutorial 2 - Final Result 6
-      :align: center 
-
 #. And the big end (which by the way expresses a big truth too):
 
-   .. image:: images/Drawing_2_Tutorial_Result_7.png
-      :height: 300px
+   .. image:: images/Drawing_2_Tutorial_Result_7.jpg
       :alt: Drawing Tutorial 2 - Final Result 7
-      :align: center 
-
+      :align: center 
\ No newline at end of file
diff --git a/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.jpg b/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..940b54c82f
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.png b/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.png
deleted file mode 100644
index e86aee1b37..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Adding_Images_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.jpg b/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..eccf37aa20
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.png b/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.png
deleted file mode 100644
index 3d2fcdc9ee..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Basic_Linear_Transform_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.jpg b/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..05e8f01232
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.png b/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.png
deleted file mode 100644
index 9cfbef6002..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Drawing_1_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.jpg b/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.jpg
new file mode 100644
index 0000000000..d650c18427
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.png b/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.png
deleted file mode 100644
index 2711552b0b..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Drawing_2_Tutorial_Result_7.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.jpg b/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..71509ba5b8
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.png b/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.png
deleted file mode 100644
index 2f9b038058..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Morphology_1_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.jpg b/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..c11f2ed024
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.png b/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.png
deleted file mode 100644
index 3152ea591e..0000000000
Binary files a/doc/tutorials/core/table_of_content_core/images/Smoothing_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/core/table_of_content_core/images/discrete_fourier_transform.png b/doc/tutorials/core/table_of_content_core/images/discrete_fourier_transform.png
new file mode 100644
index 0000000000..07bd1119f4
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/discrete_fourier_transform.png differ
diff --git a/doc/tutorials/core/table_of_content_core/images/file_input_output_with_xml_yml.png b/doc/tutorials/core/table_of_content_core/images/file_input_output_with_xml_yml.png
new file mode 100644
index 0000000000..24ae4fdd23
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/file_input_output_with_xml_yml.png differ
diff --git a/doc/tutorials/core/table_of_content_core/images/howToScanImages.jpg b/doc/tutorials/core/table_of_content_core/images/howToScanImages.jpg
new file mode 100644
index 0000000000..4e0fa26d0d
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/howToScanImages.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/images/interopOpenCV1.png b/doc/tutorials/core/table_of_content_core/images/interopOpenCV1.png
new file mode 100644
index 0000000000..040f50a003
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/interopOpenCV1.png differ
diff --git a/doc/tutorials/core/table_of_content_core/images/matMaskFilter2DOp.png b/doc/tutorials/core/table_of_content_core/images/matMaskFilter2DOp.png
new file mode 100644
index 0000000000..6795921608
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/matMaskFilter2DOp.png differ
diff --git a/doc/tutorials/core/table_of_content_core/images/matTheBasicImageStructure.jpg b/doc/tutorials/core/table_of_content_core/images/matTheBasicImageStructure.jpg
new file mode 100644
index 0000000000..ab6704a3c9
Binary files /dev/null and b/doc/tutorials/core/table_of_content_core/images/matTheBasicImageStructure.jpg differ
diff --git a/doc/tutorials/core/table_of_content_core/table_of_content_core.rst b/doc/tutorials/core/table_of_content_core/table_of_content_core.rst
index 54fd5d1549..fe5e43a09c 100644
--- a/doc/tutorials/core/table_of_content_core/table_of_content_core.rst
+++ b/doc/tutorials/core/table_of_content_core/table_of_content_core.rst
@@ -5,84 +5,217 @@
 
 Here you will learn the about the basic building blocks of the library. A must read and know for understanding how to manipulate the images on a pixel level.
 
+.. include:: ../../definitions/tocDefinitions.rst
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |MatBasicIma|  **Title:** :ref:`matTheBasicImageContainer`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You will learn how to store images in the memory and how to print out their content to the console.
+
+  =============== ======================================================
+
+  .. |MatBasicIma| image:: images/matTheBasicImageStructure.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |HowScanImag|  **Title:** :ref:`howToScanImagesOpenCV`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You'll find out how to scan images (go through each of the image pixels) with OpenCV. Bonus: time measurement with OpenCV.
+
+  =============== ======================================================
+
+  .. |HowScanImag| image:: images/howToScanImages.jpg
+                   :height: 90pt
+                   :width:  90pt
+                   
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |HowFilterIm|  **Title:** :ref:`maskOperationsFilter`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You'll find out how to scan images with neighbor access and use the :filtering:`filter2D <filter2d>` function to apply kernel filters on images.
+
+  =============== ======================================================
+
+  .. |HowFilterIm| image:: images/matMaskFilter2DOp.png
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |Beginners_4|  **Title:** :ref:`Adding_Images`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_AnaH|
+
+                  We will learn how to blend two images!
+
+  =============== ======================================================
+
+  .. |Beginners_4| image:: images/Adding_Images_Tutorial_Result_0.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ====================================================
+   |Bas_Lin_Tran| **Title:** :ref:`Basic_Linear_Transform`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_AnaH|
+
+                  We will learn how to change our image appearance!
+
+  =============== ====================================================
+
+  .. |Bas_Lin_Tran| image:: images/Basic_Linear_Transform_Tutorial_Result_0.jpg
+                              :height: 90pt
+                              :width:  90pt
+
+
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |Beginners_6|  **Title:** :ref:`Drawing_1`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_AnaH|
+
+                  We will learn how to draw simple geometry with OpenCV!
+
+  =============== ======================================================
+
+  .. |Beginners_6| image:: images/Drawing_1_Tutorial_Result_0.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |Beginners_7|  **Title:** :ref:`Drawing_2`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_AnaH|
+
+                  We will draw some *fancy-looking* stuff using OpenCV!
+
+  =============== ======================================================
+
+  .. |Beginners_7| image:: images/Drawing_2_Tutorial_Result_7.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+   |DiscFourTr|   **Title:** :ref:`discretFourierTransform`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You will see how and why use the Discrete Fourier transformation with OpenCV.
+
+  =============== ======================================================
+
+  .. |DiscFourTr| image:: images/discrete_fourier_transform.png
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+  |FileIOXMLYAML| **Title:** :ref:`fileInputOutputXMLYAML`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  You will see how to use the :xmlymlpers:`FileStorage <filestorage>` data structure of OpenCV to write and read data to XML or YAML file format.
+
+  =============== ======================================================
+
+  .. |FileIOXMLYAML| image:: images/file_input_output_with_xml_yml.png
+                   :height: 90pt
+                   :width:  90pt
+
++
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+  |InterOOpenCV1| **Title:** :ref:`InteroperabilityWithOpenCV1`
+
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_BernatG|
+
+                  Did you used OpenCV before its 2.0 version? Do you wanna know what happened with your library with 2.0? Don't you know how to convert your old OpenCV programs to the new C++ interface? Look here to shed light on all this questions.
+                  
+  =============== ======================================================
+
+  .. |InterOOpenCV1| image:: images/interopOpenCV1.png
+                   :height: 90pt
+                   :width:  90pt
+
+
+
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :hidden:
    
+   ../mat - the basic image container/mat - the basic image container
+   ../how_to_scan_images/how_to_scan_images
+   ../mat-mask-operations/mat-mask-operations
    ../adding_images/adding_images
    ../basic_linear_transform/basic_linear_transform
    ../basic_geometric_drawing/basic_geometric_drawing
    ../random_generator_and_text/random_generator_and_text
-
-.. |Author_AnaH| unicode:: Ana U+0020 Huam U+00E1 n
-
-* :ref:`Adding_Images`
-
-  =============== ======================================================
-   |Beginners_4|  *Title:* **Linear Blending**
-  
-                  *Compatibility:* > OpenCV 2.0
-                  
-                  *Author:* |Author_AnaH|
-  
-                  We will learn how to blend two images!
-  
-  =============== ======================================================
-
-.. |Beginners_4| image:: images/Adding_Images_Tutorial_Result_0.png
-                     :height: 100pt
-                     :width:  100pt
-
-* :ref:`Basic_Linear_Transform`
-
-  =============== ====================================================
-   |Bas_Lin_Tran| *Title:* **Changing the contrast and brightness of an image**
-  
-                  *Compatibility:* > OpenCV 2.0
-                  
-                  *Author:* |Author_AnaH|
-  
-                  We will learn how to change our image appearance!
-  
-  =============== ====================================================
-  
-  .. |Bas_Lin_Tran| image:: images/Basic_Linear_Transform_Tutorial_Result_0.png
-                              :height: 100pt
-                              :width:  100pt
-
-  
-                              
-* :ref:`Drawing_1`
-
-  =============== ======================================================
-   |Beginners_6|  *Title:* **Basic Drawing**
-  
-                  *Compatibility:* > OpenCV 2.0
-                  
-                  *Author:* |Author_AnaH|
-  
-                  We will learn how to draw simple geometry with OpenCV!
-  
-  =============== ======================================================
-
-.. |Beginners_6| image:: images/Drawing_1_Tutorial_Result_0.png
-                 :height: 100pt
-                 :width:  100pt
-
-
-* :ref:`Drawing_2`
-
-  =============== ======================================================
-   |Beginners_7|  *Title:* **Cool Drawing**
-
-                  *Compatibility:* > OpenCV 2.0
-                  
-                  *Author:* |Author_AnaH|
-
-                  We will draw some *fancy-looking* stuff using OpenCV!
- 
-  =============== ======================================================
- 
-  .. |Beginners_7| image:: images/Drawing_2_Tutorial_Result_7.png
-                   :height: 100pt
-                   :width:  100pt
-
+   ../discrete_fourier_transform/discrete_fourier_transform
+   ../file_input_output_with_xml_yml/file_input_output_with_xml_yml
+   ../interoperability_with_OpenCV_1/interoperability_with_OpenCV_1
\ No newline at end of file
diff --git a/doc/tutorials/definitions/README.txt b/doc/tutorials/definitions/README.txt
index e69de29bb2..829e27cacb 100644
--- a/doc/tutorials/definitions/README.txt
+++ b/doc/tutorials/definitions/README.txt
@@ -0,0 +1 @@
+Include in this directory only defintion files. None of the reST files entered here will be parsed by the Sphinx Builder.
\ No newline at end of file
diff --git a/doc/tutorials/definitions/formatStyleSizeDef.rst b/doc/tutorials/definitions/formatStyleSizeDef.rst
new file mode 100644
index 0000000000..c4b8785979
--- /dev/null
+++ b/doc/tutorials/definitions/formatStyleSizeDef.rst
@@ -0,0 +1,5 @@
+.. |TOC_Image_Width| replace:: 100pt
+
+.. |TOC_Image_Height| replace:: 100pt
+
+.. |TOC
diff --git a/doc/tutorials/definitions/tocDefinitions.rst b/doc/tutorials/definitions/tocDefinitions.rst
new file mode 100644
index 0000000000..2621c58bdb
--- /dev/null
+++ b/doc/tutorials/definitions/tocDefinitions.rst
@@ -0,0 +1,8 @@
+.. |Author_AnaH| unicode:: Ana U+0020 Huam U+00E1 n
+.. |Author_BernatG| unicode:: Bern U+00E1 t U+0020 G U+00E1 bor
+.. |Author_AndreyK| unicode:: Andrey U+0020 Kamaev
+.. |Author_LeonidBLB| unicode:: Leonid U+0020 Beynenson
+.. |Author_VictorE| unicode:: Victor U+0020 Eruhimov 
+.. |Author_FernandoI| unicode:: Fernando U+0020 Iglesias U+0020 Garc U+00ED a 
+
+
diff --git a/doc/tutorials/features2d/detection_of_planar_objects/detection_of_planar_objects.rst b/doc/tutorials/features2d/detection_of_planar_objects/detection_of_planar_objects.rst
new file mode 100644
index 0000000000..2345b9e5a8
--- /dev/null
+++ b/doc/tutorials/features2d/detection_of_planar_objects/detection_of_planar_objects.rst
@@ -0,0 +1,72 @@
+.. _detectionOfPlanarObjects:
+
+Detection of planar objects
+***************************
+
+.. highlight:: cpp
+
+The goal of this tutorial is to learn how to use *features2d* and *calib3d* modules for detecting known planar objects in scenes. 
+
+*Test data*: use images in your data folder, for instance, ``box.png`` and ``box_in_scene.png``. 
+
+#.
+    Create a new console project. Read two input images. ::
+
+        Mat img1 = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
+        Mat img2 = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
+
+#.
+    Detect keypoints in both images. ::
+
+        // detecting keypoints
+        FastFeatureDetector detector(15);
+        vector<KeyPoint> keypoints1;
+        detector.detect(img1, keypoints1);
+        
+        ... // do the same for the second image
+
+#.
+    Compute descriptors for each of the keypoints. ::
+
+        // computing descriptors
+        SurfDescriptorExtractor extractor;
+        Mat descriptors1;
+        extractor.compute(img1, keypoints1, descriptors1);
+        
+        ... // process keypoints from the second image as well
+
+#.
+    Now, find the closest matches between descriptors from the first image to the second: ::
+
+        // matching descriptors
+        BruteForceMatcher<L2<float> > matcher;
+        vector<DMatch> matches;
+        matcher.match(descriptors1, descriptors2, matches);
+
+#.
+    Visualize the results: ::
+
+        // drawing the results
+        namedWindow("matches", 1);
+        Mat img_matches;
+        drawMatches(img1, keypoints1, img2, keypoints2, matches, img_matches);
+        imshow("matches", img_matches);
+        waitKey(0);
+
+#.
+    Find the homography transformation between two sets of points: ::
+
+        vector<Point2f> points1, points2;
+        // fill the arrays with the points
+        ....
+        Mat H = findHomography(Mat(points1), Mat(points2), CV_RANSAC, ransacReprojThreshold);
+
+
+#.
+    Create a set of inlier matches and draw them. Use perspectiveTransform function to map points with homography:
+
+        Mat points1Projected;
+        perspectiveTransform(Mat(points1), points1Projected, H);
+
+#.
+    Use ``drawMatches`` for drawing inliers. 
diff --git a/doc/tutorials/features2d/table_of_content_features2d/images/detection_of_planar_objects.png b/doc/tutorials/features2d/table_of_content_features2d/images/detection_of_planar_objects.png
new file mode 100644
index 0000000000..92de70cfdc
Binary files /dev/null and b/doc/tutorials/features2d/table_of_content_features2d/images/detection_of_planar_objects.png differ
diff --git a/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Corner_Subpixeles_Cover.jpg b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Corner_Subpixeles_Cover.jpg
new file mode 100644
index 0000000000..61ec8d1d89
Binary files /dev/null and b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Corner_Subpixeles_Cover.jpg differ
diff --git a/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Generic_Corner_Detector_Cover.jpg b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Generic_Corner_Detector_Cover.jpg
new file mode 100644
index 0000000000..89fc7bef7c
Binary files /dev/null and b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Generic_Corner_Detector_Cover.jpg differ
diff --git a/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Harris_Detector_Cover.jpg b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Harris_Detector_Cover.jpg
new file mode 100644
index 0000000000..bc4d816e32
Binary files /dev/null and b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Harris_Detector_Cover.jpg differ
diff --git a/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Shi_Tomasi_Detector_Cover.jpg b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Shi_Tomasi_Detector_Cover.jpg
new file mode 100644
index 0000000000..e0ee608d9c
Binary files /dev/null and b/doc/tutorials/features2d/table_of_content_features2d/images/trackingmotion/Shi_Tomasi_Detector_Cover.jpg differ
diff --git a/doc/tutorials/features2d/table_of_content_features2d/table_of_content_features2d.rst b/doc/tutorials/features2d/table_of_content_features2d/table_of_content_features2d.rst
index 725af28d80..062f03fd70 100644
--- a/doc/tutorials/features2d/table_of_content_features2d/table_of_content_features2d.rst
+++ b/doc/tutorials/features2d/table_of_content_features2d/table_of_content_features2d.rst
@@ -5,4 +5,115 @@
 
 Learn about how to use the feature points  detectors, descriptors and matching framework found inside OpenCV.
 
-.. include:: ../../definitions/noContent.rst 
+.. include:: ../../definitions/tocDefinitions.rst 
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |Harris|             **Title:** :ref:`harris_detector`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+                        
+                        Why is it a good idea to track corners? We learn to use the Harris method to detect corners
+  
+  ===================== ==============================================
+  
+  .. |Harris| image:: images/trackingmotion/Harris_Detector_Cover.jpg
+                   :height: 90pt
+                   :width:  90pt
+  
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |ShiTomasi|          **Title:** :ref:`good_features_to_track`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+                        
+                        Where we use an improved method to detect corners more accuratelyI
+  
+  ===================== ==============================================
+  
+  .. |ShiTomasi| image:: images/trackingmotion/Shi_Tomasi_Detector_Cover.jpg
+                      :height: 90pt
+                      :width:  90pt
+
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |GenericCorner|      **Title:** :ref:`generic_corner_detector`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+                        
+                        Here you will learn how to use OpenCV functions to make your personalized corner detector!
+  
+  ===================== ==============================================
+  
+  .. |GenericCorner| image:: images/trackingmotion/Generic_Corner_Detector_Cover.jpg
+                          :height: 90pt
+                          :width:  90pt
+
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |Subpixel|             **Title:** :ref:`corner_subpixeles`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+                        
+                        Is pixel resolution enough? Here we learn a simple method to improve our accuracy.
+  
+  ===================== ==============================================
+  
+  .. |Subpixel| image:: images/trackingmotion/Corner_Subpixeles_Cover.jpg
+                     :height: 90pt
+                     :width:  90pt
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ===================== ==============================================
+   |DetectPlanar|       **Title:** :ref:`detectionOfPlanarObjects`
+
+                        *Compatibility:* > OpenCV 2.0
+
+                        *Author:* |Author_VictorE|
+
+                        You will use *features2d* and *calib3d* modules for detecting known planar objects in scenes. 
+
+  ===================== ==============================================
+
+  .. |DetectPlanar| image:: images/detection_of_planar_objects.png
+                     :height: 90pt
+                     :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../trackingmotion/harris_detector/harris_detector
+   ../trackingmotion/good_features_to_track/good_features_to_track.rst
+   ../trackingmotion/generic_corner_detector/generic_corner_detector
+   ../trackingmotion/corner_subpixeles/corner_subpixeles
+   ../detection_of_planar_objects/detection_of_planar_objects
\ No newline at end of file
diff --git a/doc/tutorials/features2d/trackingmotion/corner_subpixeles/corner_subpixeles.rst b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/corner_subpixeles.rst
new file mode 100644
index 0000000000..e3291a8556
--- /dev/null
+++ b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/corner_subpixeles.rst
@@ -0,0 +1,138 @@
+.. _corner_subpixeles:
+
+Detecting corners location in subpixeles
+****************************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :corner_sub_pix:`cornerSubPix <>` to find more exact corner positions (more exact than integer pixels).
+
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+
+   int maxCorners = 10;
+   int maxTrackbar = 25;
+
+   RNG rng(12345);
+   char* source_window = "Image";
+
+   /// Function header
+   void goodFeaturesToTrack_Demo( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create Window
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+     /// Create Trackbar to set the number of corners
+     createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo);  
+
+     imshow( source_window, src );
+
+     goodFeaturesToTrack_Demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /**
+    * @function goodFeaturesToTrack_Demo.cpp
+    * @brief Apply Shi-Tomasi corner detector
+    */
+   void goodFeaturesToTrack_Demo( int, void* )
+   {
+     if( maxCorners < 1 ) { maxCorners = 1; }
+  
+     /// Parameters for Shi-Tomasi algorithm
+     vector<Point2f> corners;
+     double qualityLevel = 0.01;
+     double minDistance = 10;
+     int blockSize = 3;
+     bool useHarrisDetector = false;
+     double k = 0.04;
+
+     /// Copy the source image
+     Mat copy;
+     copy = src.clone();
+
+     /// Apply corner detection
+     goodFeaturesToTrack( src_gray, 
+	  	          corners,
+		          maxCorners,
+		          qualityLevel,
+		          minDistance,
+		          Mat(),
+		          blockSize,
+		          useHarrisDetector,
+		          k );
+  
+
+     /// Draw corners detected
+     cout<<"** Number of corners detected: "<<corners.size()<<endl;
+     int r = 4;
+     for( int i = 0; i < corners.size(); i++ )
+        { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), 
+                                                    rng.uniform(0,255)), -1, 8, 0 ); }
+
+     /// Show what you got
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, copy );  
+
+     /// Set the neeed parameters to find the refined corners
+     Size winSize = Size( 5, 5 );
+     Size zeroZone = Size( -1, -1 );
+     TermCriteria criteria = TermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 40, 0.001 );
+
+     /// Calculate the refined corner locations
+     cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
+
+     /// Write them down
+     for( int i = 0; i < corners.size(); i++ )
+        { cout<<" -- Refined Corner ["<<i<<"]  ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }	
+   }
+
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/Corner_Subpixeles_Original_Image.jpg
+              :align: center 
+  
+Here is the result:
+
+.. image:: images/Corner_Subpixeles_Result.jpg
+              :align: center   
+
diff --git a/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Original_Image.jpg b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Original_Image.jpg
new file mode 100644
index 0000000000..83dace0f01
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Original_Image.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Result.jpg b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Result.jpg
new file mode 100644
index 0000000000..7169027682
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/corner_subpixeles/images/Corner_Subpixeles_Result.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/generic_corner_detector/generic_corner_detector.rst b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/generic_corner_detector.rst
new file mode 100644
index 0000000000..bc7887f29f
--- /dev/null
+++ b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/generic_corner_detector.rst
@@ -0,0 +1,159 @@
+.. _generic_corner_detector:
+
+Creating yor own corner detector
+********************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :corner_eigenvals_and_vecs:`cornerEigenValsAndVecs <>` to find the eigenvalues and eigenvectors to determine if a pixel is a corner.
+   * Use the OpenCV function :corner_min_eigenval:`cornerMinEigenVal <>` to find the minimum eigenvalues for corner detection. 
+   * To implement our own version of the Harris detector as well as the Shi-Tomasi detector, by using the two functions above.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray; 
+   Mat myHarris_dst; Mat myHarris_copy; Mat Mc;
+   Mat myShiTomasi_dst; Mat myShiTomasi_copy; 
+
+   int myShiTomasi_qualityLevel = 50;
+   int myHarris_qualityLevel = 50;
+   int max_qualityLevel = 100;
+
+   double myHarris_minVal; double myHarris_maxVal;
+   double myShiTomasi_minVal; double myShiTomasi_maxVal;
+
+   RNG rng(12345);
+
+   char* myHarris_window = "My Harris corner detector";
+   char* myShiTomasi_window = "My Shi Tomasi corner detector";
+
+   /// Function headers
+   void myShiTomasi_function( int, void* );
+   void myHarris_function( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Set some parameters
+     int blockSize = 3; int apertureSize = 3;
+
+     /// My Harris matrix -- Using cornerEigenValsAndVecs
+     myHarris_dst = Mat::zeros( src_gray.size(), CV_32FC(6) );
+     Mc = Mat::zeros( src_gray.size(), CV_32FC1 );
+
+     cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize, BORDER_DEFAULT );
+
+     /* calculate Mc */ 
+     for( int j = 0; j < src_gray.rows; j++ )
+        { for( int i = 0; i < src_gray.cols; i++ )
+             {
+               float lambda_1 = myHarris_dst.at<float>( j, i, 0 );
+               float lambda_2 = myHarris_dst.at<float>( j, i, 1 );
+               Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 );
+             }
+        }
+
+     minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal, 0, 0, Mat() );
+  
+     /* Create Window and Trackbar */
+     namedWindow( myHarris_window, CV_WINDOW_AUTOSIZE );
+     createTrackbar( " Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, 
+                       myHarris_function );  
+     myHarris_function( 0, 0 );
+
+     /// My Shi-Tomasi -- Using cornerMinEigenVal
+     myShiTomasi_dst = Mat::zeros( src_gray.size(), CV_32FC1 );  
+     cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize, BORDER_DEFAULT );
+
+     minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal, 0, 0, Mat() );
+
+     /* Create Window and Trackbar */
+     namedWindow( myShiTomasi_window, CV_WINDOW_AUTOSIZE );   
+     createTrackbar( " Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, 
+                        myShiTomasi_function );  
+     myShiTomasi_function( 0, 0 );
+  
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function myShiTomasi_function  */
+   void myShiTomasi_function( int, void* )
+   {
+     myShiTomasi_copy = src.clone();
+
+     if( myShiTomasi_qualityLevel < 1 ) { myShiTomasi_qualityLevel = 1; }
+
+     for( int j = 0; j < src_gray.rows; j++ )
+        { for( int i = 0; i < src_gray.cols; i++ )
+             {
+               if( myShiTomasi_dst.at<float>(j,i) > myShiTomasi_minVal + ( myShiTomasi_maxVal - 
+                        myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
+                 { circle( myShiTomasi_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), 
+                            rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); }
+             }
+        }
+     imshow( myShiTomasi_window, myShiTomasi_copy );
+   }
+
+   /** @function myHarris_function */
+   void myHarris_function( int, void* )
+   {
+     myHarris_copy = src.clone();
+
+     if( myHarris_qualityLevel < 1 ) { myHarris_qualityLevel = 1; }
+
+     for( int j = 0; j < src_gray.rows; j++ )
+        { for( int i = 0; i < src_gray.cols; i++ )
+             {
+               if( Mc.at<float>(j,i) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )
+                                                            *myHarris_qualityLevel/max_qualityLevel )
+                 { circle( myHarris_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), rng.uniform(0,255), 
+                           rng.uniform(0,255) ), -1, 8, 0 ); }
+             } 
+        }
+     imshow( myHarris_window, myHarris_copy );
+   }
+
+
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/My_Harris_corner_detector_Result.jpg
+              :align: center   
+
+
+.. image:: images/My_Shi_Tomasi_corner_detector_Result.jpg
+              :align: center   
+
diff --git a/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Harris_corner_detector_Result.jpg b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Harris_corner_detector_Result.jpg
new file mode 100644
index 0000000000..d2ef409b19
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Harris_corner_detector_Result.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Shi_Tomasi_corner_detector_Result.jpg b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Shi_Tomasi_corner_detector_Result.jpg
new file mode 100644
index 0000000000..0cca430d8c
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/generic_corner_detector/images/My_Shi_Tomasi_corner_detector_Result.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/good_features_to_track/good_features_to_track.rst b/doc/tutorials/features2d/trackingmotion/good_features_to_track/good_features_to_track.rst
new file mode 100644
index 0000000000..00782364b2
--- /dev/null
+++ b/doc/tutorials/features2d/trackingmotion/good_features_to_track/good_features_to_track.rst
@@ -0,0 +1,122 @@
+.. _good_features_to_track:
+
+Shi-Tomasi corner detector
+**************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the function :good_features_to_track:`goodFeaturesToTrack <>` to detect corners using the Shi-Tomasi method.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+
+   int maxCorners = 23;
+   int maxTrackbar = 100;
+
+   RNG rng(12345);
+   char* source_window = "Image";
+
+   /// Function header
+   void goodFeaturesToTrack_Demo( int, void* );
+
+   /**
+    * @function main
+    */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create Window
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+     /// Create Trackbar to set the number of corners
+     createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  
+
+     imshow( source_window, src );
+
+     goodFeaturesToTrack_Demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /**
+    * @function goodFeaturesToTrack_Demo.cpp
+    * @brief Apply Shi-Tomasi corner detector
+    */
+   void goodFeaturesToTrack_Demo( int, void* ) 
+   {
+     if( maxCorners < 1 ) { maxCorners = 1; }
+  
+     /// Parameters for Shi-Tomasi algorithm
+     vector<Point2f> corners;
+     double qualityLevel = 0.01;
+     double minDistance = 10;
+     int blockSize = 3;
+     bool useHarrisDetector = false;
+     double k = 0.04;
+
+     /// Copy the source image
+     Mat copy;
+     copy = src.clone();
+
+     /// Apply corner detection
+     goodFeaturesToTrack( src_gray, 
+	   	          corners,
+		          maxCorners,
+		          qualityLevel,
+		          minDistance,
+		          Mat(),
+		          blockSize,
+		          useHarrisDetector,
+		          k );
+  
+
+     /// Draw corners detected
+     cout<<"** Number of corners detected: "<<corners.size()<<endl;
+     int r = 4;
+     for( int i = 0; i < corners.size(); i++ )
+        { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), 
+                 rng.uniform(0,255)), -1, 8, 0 ); }
+
+     /// Show what you got
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, copy );  
+   }
+
+Explanation
+============
+
+Result
+======
+
+.. image:: images/Shi_Tomasi_Detector_Result.jpg
+              :align: center   
+
+
diff --git a/doc/tutorials/features2d/trackingmotion/good_features_to_track/images/Shi_Tomasi_Detector_Result.jpg b/doc/tutorials/features2d/trackingmotion/good_features_to_track/images/Shi_Tomasi_Detector_Result.jpg
new file mode 100644
index 0000000000..abfad97291
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/good_features_to_track/images/Shi_Tomasi_Detector_Result.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/harris_detector/harris_detector.rst b/doc/tutorials/features2d/trackingmotion/harris_detector/harris_detector.rst
new file mode 100644
index 0000000000..de849c74f7
--- /dev/null
+++ b/doc/tutorials/features2d/trackingmotion/harris_detector/harris_detector.rst
@@ -0,0 +1,114 @@
+.. _harris_detector:
+
+Harris corner detector
+**********************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the function :corner_harris:`cornerHarris <>` to detect corners using the Harris-Stephens method.
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv; 
+   using namespace std;
+
+   /// Global variables
+   Mat src, src_gray;
+   int thresh = 200;
+   int max_thresh = 255;
+
+   char* source_window = "Source image";
+   char* corners_window = "Corners detected";
+
+   /// Function header
+   void cornerHarris_demo( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Create a window and a trackbar
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
+     imshow( source_window, src );
+  
+     cornerHarris_demo( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function cornerHarris_demo */
+   void cornerHarris_demo( int, void* )
+   {
+
+     Mat dst, dst_norm, dst_norm_scaled;
+     dst = Mat::zeros( src.size(), CV_32FC1 );
+
+     /// Detector parameters
+     int blockSize = 2;
+     int apertureSize = 3;
+     double k = 0.04;
+ 
+     /// Detecting corners
+     cornerHarris( src_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT );
+
+     /// Normalizing
+     normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
+     convertScaleAbs( dst_norm, dst_norm_scaled ); 
+
+     /// Drawing a circle around corners
+     for( int j = 0; j < dst_norm.rows ; j++ )
+        { for( int i = 0; i < dst_norm.cols; i++ )
+             {
+               if( (int) dst_norm.at<float>(j,i) > thresh )
+                 { 
+                  circle( dst_norm_scaled, Point( i, j ), 5,  Scalar(0), 2, 8, 0 ); 
+                 }
+             } 
+        }    
+     /// Showing the result 
+     namedWindow( corners_window, CV_WINDOW_AUTOSIZE );
+     imshow( corners_window, dst_norm_scaled );
+   }
+
+
+Explanation
+============
+
+Result
+======
+
+The original image:
+
+.. image:: images/Harris_Detector_Original_Image.jpg
+              :align: center   
+
+The detected corners are surrounded by a small black circle
+
+.. image:: images/Harris_Detector_Result.jpg
+              :align: center   
+
+
diff --git a/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Original_Image.jpg b/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Original_Image.jpg
new file mode 100644
index 0000000000..4dd0778b9e
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Original_Image.jpg differ
diff --git a/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Result.jpg b/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Result.jpg
new file mode 100644
index 0000000000..189f318118
Binary files /dev/null and b/doc/tutorials/features2d/trackingmotion/harris_detector/images/Harris_Detector_Result.jpg differ
diff --git a/doc/tutorials/general/table_of_content_general/table_of_content_general.rst b/doc/tutorials/general/table_of_content_general/table_of_content_general.rst
index 36dbac2b60..2a6d57ffb9 100644
--- a/doc/tutorials/general/table_of_content_general/table_of_content_general.rst
+++ b/doc/tutorials/general/table_of_content_general/table_of_content_general.rst
@@ -6,3 +6,8 @@ General tutorials
 These tutorials are the bottom of the iceberg as they link together multiple of the modules presented above in order to solve complex problems.
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak
+
diff --git a/doc/tutorials/gpu/table_of_content_gpu/table_of_content_gpu.rst b/doc/tutorials/gpu/table_of_content_gpu/table_of_content_gpu.rst
index 1c2e91d9e4..cadbcfd384 100644
--- a/doc/tutorials/gpu/table_of_content_gpu/table_of_content_gpu.rst
+++ b/doc/tutorials/gpu/table_of_content_gpu/table_of_content_gpu.rst
@@ -6,3 +6,7 @@
 Squeeze out every little computation power from your system by using the power of your video card to run the OpenCV algorithms.
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak
diff --git a/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.jpg b/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..e914cab1d5
Binary files /dev/null and b/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.png b/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.png
deleted file mode 100644
index d3b85ba523..0000000000
Binary files a/doc/tutorials/highgui/table_of_content_highgui/images/Adding_Trackbars_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/highgui/table_of_content_highgui/images/video-input-psnr-ssim.png b/doc/tutorials/highgui/table_of_content_highgui/images/video-input-psnr-ssim.png
new file mode 100644
index 0000000000..de8c2835a6
Binary files /dev/null and b/doc/tutorials/highgui/table_of_content_highgui/images/video-input-psnr-ssim.png differ
diff --git a/doc/tutorials/highgui/table_of_content_highgui/table_of_content_highgui.rst b/doc/tutorials/highgui/table_of_content_highgui/table_of_content_highgui.rst
index 56f80ce49e..b03f1a66c7 100644
--- a/doc/tutorials/highgui/table_of_content_highgui/table_of_content_highgui.rst
+++ b/doc/tutorials/highgui/table_of_content_highgui/table_of_content_highgui.rst
@@ -5,22 +5,52 @@
 
 This section contains valuable tutorials about how to read/save your image/video files and how to use the built-in graphical user interface of the library. 
 
+.. include:: ../../definitions/tocDefinitions.rst
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  =============== ======================================================
+  |Beginners_5|   *Title:* :ref:`Adding_Trackbars`
+  
+                  *Compatibility:* > OpenCV 2.0
+
+                  *Author:* |Author_AnaH|
+  
+                  We will learn how to add a Trackbar to our applications
+  
+  =============== ======================================================
+  
+  .. |Beginners_5| image:: images/Adding_Trackbars_Tutorial_Cover.jpg
+                   :height: 90pt
+                   :width:  90pt
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =============== ======================================================
+  |hVideoInput|   *Title:* :ref:`videoInputPSNRMSSIM`
+
+                  *Compatibility:* > OpenCV 2.0
+                  
+                  *Author:* |Author_BernatG|
+
+                  You will learn how to read video streams, and how to calculate similarity values such as PSNR or SSIM.
+
+  =============== ======================================================
+
+  .. |hVideoInput| image:: images/video-input-psnr-ssim.png
+                   :height: 90pt
+                   :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :hidden:
-   
+
    ../trackbar/trackbar
-
-* :ref:`Adding_Trackbars`
-
-     =============== ======================================================
-     |Beginners_5|   *Title:* **Creating Trackbars**
-
-                     *Compatibility:* > OpenCV 2.0
-
-                     We will learn how to add a Trackbar to our applications
-    
-     =============== ======================================================
-    
-     .. |Beginners_5| image:: images/Adding_Trackbars_Tutorial_Cover.png
-                      :height: 100pt
-                      :width:  100pt
+   ../video-input-psnr-ssim/video-input-psnr-ssim
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Cover.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Cover.png
deleted file mode 100644
index 8dfab5ba73..0000000000
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.jpg b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..d18529711b
Binary files /dev/null and b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.png
deleted file mode 100644
index 29149f0253..0000000000
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_0.png and /dev/null differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.jpg b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.jpg
new file mode 100644
index 0000000000..a1ef11f9c6
Binary files /dev/null and b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.jpg differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.png
deleted file mode 100644
index 4c8aba3ce2..0000000000
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1.png and /dev/null differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1a.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1a.png
deleted file mode 100644
index feec159437..0000000000
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1a.png and /dev/null differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1b.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1b.png
deleted file mode 100644
index 5873859e31..0000000000
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Result_1b.png and /dev/null differ
diff --git a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Trackbar.png b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Trackbar.png
index a74327f8aa..16a6feec5a 100644
Binary files a/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Trackbar.png and b/doc/tutorials/highgui/trackbar/images/Adding_Trackbars_Tutorial_Trackbar.png differ
diff --git a/doc/tutorials/highgui/trackbar/trackbar.rst b/doc/tutorials/highgui/trackbar/trackbar.rst
index c5b77abed1..21f8b3687c 100644
--- a/doc/tutorials/highgui/trackbar/trackbar.rst
+++ b/doc/tutorials/highgui/trackbar/trackbar.rst
@@ -145,15 +145,14 @@ Result
 
 * Our program produces the following output:
 
-  .. image:: images/Adding_Trackbars_Tutorial_Result_0.png
+  .. image:: images/Adding_Trackbars_Tutorial_Result_0.jpg
      :alt: Adding Trackbars - Windows Linux
      :align: center 
 
 * As a manner of practice, you can also add 02 trackbars for the program made in :ref:`Basic_Linear_Transform`. One trackbar to set :math:`\alpha` and another for :math:`\beta`. The output might look like:
 
-  .. image:: images/Adding_Trackbars_Tutorial_Result_1.png
+  .. image:: images/Adding_Trackbars_Tutorial_Result_1.jpg
      :alt: Adding Trackbars - Lena
-     :height: 500px
      :align: center 
 
 
diff --git a/doc/tutorials/highgui/video-input-psnr-ssim/images/outputVideoInput.png b/doc/tutorials/highgui/video-input-psnr-ssim/images/outputVideoInput.png
new file mode 100644
index 0000000000..7df9235d71
Binary files /dev/null and b/doc/tutorials/highgui/video-input-psnr-ssim/images/outputVideoInput.png differ
diff --git a/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.rst b/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.rst
new file mode 100644
index 0000000000..4bde0be6bb
--- /dev/null
+++ b/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.rst
@@ -0,0 +1,216 @@
+.. _videoInputPSNRMSSIM:
+
+Video Input with OpenCV and similarity measurement
+**************************************************
+
+Goal
+====
+
+Today it is common to have a digital video recording system at your disposal. Therefore, you will eventually come to the situation that you no longer process a batch of images, but video streams. These may be of two kinds: real-time image feed (in the case of a webcam) or prerecorded and hard disk drive stored files. Luckily OpenCV threats these two in the same manner, with the same C++ class. So here's what you'll learn in this tutorial:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + How to open and read video streams
+   + Two ways for checking image similarity: PSNR and SSIM
+
+The source code
+===============
+
+As a test case where to show off these using OpenCV I've created a small program that reads in two video files and performs a similarity check between them. This is something you could use to check just how well a new video compressing algorithms works. Let there be a reference (original) video like :download:`this small Megamind clip <../../../../samples/cpp/tutorial_code/highgui/video-input-psnr-ssim/video/Megamind.avi>` and :download:`a compressed version of it <../../../../samples/cpp/tutorial_code/highgui/video-input-psnr-ssim/video/Megamind_bugy.avi>`. You may also find the source code and these video file in the :file:`samples/cpp/tutorial_code/highgui/video-input-psnr-ssim/` folder of the OpenCV source library.
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/HighGUI\video-input-psnr-ssim\video-input-psnr-ssim.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+   :lines: 1-14, 28-29, 31-205
+
+How to read a video stream (online-camera or offline-file)?
+===========================================================
+
+Essentially, all the functionalities required for video manipulation is integrated in the :huivideo:`VideoCapture <videocapture>` C++ class. This on itself builds on the FFmpeg open source library. This is a basic dependency of OpenCV so you shouldn't need to worry about this. A video is composed of a succession of images, we refer to these in the literature as frames. In case of a video file there is a *frame rate* specifying just how long is between two frames. While for the video cameras usually there is a limit of just how many frames they can digitalize per second, this property is less important as at any time the camera sees the current snapshot of the world. 
+
+The first task you need to do is to assign to a :huivideo:`VideoCapture <videocapture>` class its source. You can do this either via the :huivideo:`constructor <videocapture-videocapture>` or its :huivideo:`open <videocapture-open>` function. If this argument is an integer then you will bind the class to a camera, a device. The number passed here is the ID of the device, assigned by the operating system. If you have a single camera attached to your system its ID will probably be zero and further ones increasing from there. If the parameter passed to these is a string it will refer to a video file, and the string points to the location and name of the file. For example, to the upper source code a valid command line is: 
+
+.. code-block:: bash
+
+   video/Megamind.avi video/Megamind_bug.avi  35 10
+
+We do a similarity check. This requires a reference and a test case video file. The first two arguments refer to this. Here we use a relative address. This means that the application will look into its current working directory and open the video folder and try to find inside this the *Megamind.avi* and the *Megamind_bug.avi*.
+
+.. code-block:: cpp
+
+   const string sourceReference = argv[1],sourceCompareWith = argv[2];
+
+   VideoCapture captRefrnc(sourceReference);
+   // or
+   VideoCapture captUndTst;
+   captUndTst.open(sourceCompareWith);
+
+To check if the binding of the class to a video source was successful or not use the :huivideo:`isOpened <video-isopened>` function:
+
+.. code-block:: cpp
+
+   if ( !captRefrnc.isOpened())
+     {
+     cout  << "Could not open reference " << sourceReference << endl;
+     return -1;
+     }
+
+Closing the video is automatic when the objects destructor is called. However, if you want to close it before this you need to call its :huivideo:`release <videocapture-release>` function. The frames of the video are just simple images. Therefore, we just need to extract them from the :huivideo:`VideoCapture <videocapture>` object and put them inside a *Mat* one. The video streams are sequential. You may get the frames one after another by the :huivideo:`read <videocapture-read>` or the overloaded >> operator: 
+
+.. code-block:: cpp
+
+   Mat frameReference, frameUnderTest;
+   captRefrnc >> frameReference;
+   captUndTst.open(frameUnderTest);
+
+The upper read operations will leave empty the *Mat* objects if no frame could be acquired (either cause the video stream was closed or you got to the end of the video file). We can check this with a simple if: 
+
+.. code-block:: cpp
+
+   if( frameReference.empty()  || frameUnderTest.empty())
+   {
+    // exit the program
+   }
+
+A read method is made of a frame grab and a decoding applied on that. You may call explicitly these two by using the :huivideo:`grab <videocapture-grab>` and then the :huivideo:`retrieve <videocapture-retrieve>` functions. 
+
+Videos have many-many information attached to them besides the content of the frames. These are usually numbers, however in some case it may be short character sequences (4 bytes or less). Due to this to acquire these information there is a general function named :huivideo:`get <videocapture-get>` that returns double values containing these properties. Use bitwise operations to decode the characters from a double type and conversions where valid values are only integers. Its single argument is the ID of the queried property. For example, here we get the size of the frames in the reference and test case video file; plus the number of frames inside the reference. 
+
+.. code-block:: cpp
+
+   Size refS = Size((int) captRefrnc.get(CV_CAP_PROP_FRAME_WIDTH),
+                    (int) captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
+
+   cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
+        << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
+
+When you are working with videos you may often want to control these values yourself. To do this there is a :huivideo:`set <videocapture-set>` function. Its first argument remains the name of the property you want to change and there is a second of double type containing the value to be set. It will return true if it succeeds and false otherwise. Good examples for this is seeking in a video file to a given time or frame: 
+
+.. code-block:: cpp
+
+   captRefrnc.set(CV_CAP_PROP_POS_MSEC, 1.2);  // go to the 1.2 second in the video
+   captRefrnc.set(CV_CAP_PROP_POS_FRAMES, 10); // go to the 10th frame of the video
+   // now a read operation would read the frame at the set position
+
+For properties you can read and change look into the documentation of the :huivideo:`get <videocapture-get>` and :huivideo:`set <videocapture-set>` functions. 
+
+
+Image similarity - PSNR and SSIM
+================================
+
+We want to check just how imperceptible our video converting operation went, therefore we need a system to check frame by frame the similarity or differences. The most common algorithm used for this is the PSNR (aka **Peak signal-to-noise ratio**). The simplest definition of this starts out from the *mean squad error*. Let there be two images: I1 and I2; with a two dimensional size i and j, composed of c number of channels.
+
+.. math::
+
+   MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}
+
+Then the PSNR is expressed as:
+
+.. math::
+
+   PSNR = 10 \cdot \log_{10} \left( \frac{MAX_I^2}{MSE} \right)
+
+Here the :math:`MAX_I^2` is the maximum valid value for a pixel. In case of the simple single byte image per pixel per channel this is 255. When two images are the same the MSE will give zero, resulting in an invalid divide by zero operation in the PSNR formula. In this case the PSNR is undefined and as we'll need to handle this case separately. The transition to a logarithmic scale is made because the pixel values have a very wide dynamic range. All this translated to OpenCV and a C++ function looks like: 
+
+.. code-block:: cpp
+
+   double getPSNR(const Mat& I1, const Mat& I2)
+   {
+    Mat s1;
+    absdiff(I1, I2, s1);       // |I1 - I2|
+    s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
+    s1 = s1.mul(s1);           // |I1 - I2|^2
+
+    Scalar s = sum(s1);         // sum elements per channel
+
+    double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double  mse =sse /(double)(I1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+   }
+
+Typically result values are anywhere between 30 and 50 for video compression, where higher is better. If the images significantly differ you'll get much lower ones like 15 and so. This similarity check is easy and fast to calculate, however in practice it may turn out somewhat inconsistent with human eye perception. The **structural similarity** algorithm aims to correct this. 
+
+Describing the methods goes well beyond the purpose of this tutorial. For that I invite you to read the article introducing it. Nevertheless, you can get a good image of it by looking at the OpenCV implementation below. 
+
+.. seealso::
+
+   SSIM is described more in-depth in the: "Z. Wang, A. C. Bovik, H. R. Sheikh and E. P. Simoncelli, "Image quality assessment: From error visibility to structural similarity," IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, Apr. 2004." article. 
+
+.. code-block:: cpp
+
+   Scalar getMSSIM( const Mat& i1, const Mat& i2)
+   {
+    const double C1 = 6.5025, C2 = 58.5225;
+    /***************************** INITS **********************************/
+    int d     = CV_32F;
+
+    Mat I1, I2;
+    i1.convertTo(I1, d);           // cannot calculate on one byte large values
+    i2.convertTo(I2, d);
+
+    Mat I2_2   = I2.mul(I2);        // I2^2
+    Mat I1_2   = I1.mul(I1);        // I1^2
+    Mat I1_I2  = I1.mul(I2);        // I1 * I2
+
+    /***********************PRELIMINARY COMPUTING ******************************/
+
+    Mat mu1, mu2;   // 
+    GaussianBlur(I1, mu1, Size(11, 11), 1.5);
+    GaussianBlur(I2, mu2, Size(11, 11), 1.5);
+
+    Mat mu1_2   =   mu1.mul(mu1);
+    Mat mu2_2   =   mu2.mul(mu2);
+    Mat mu1_mu2 =   mu1.mul(mu2);
+
+    Mat sigma1_2, sigma2_2, sigma12;
+
+    GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    ///////////////////////////////// FORMULA ////////////////////////////////
+    Mat t1, t2, t3;
+
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    Mat ssim_map;
+    divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
+
+    Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
+    return mssim;
+   }
+
+This will return a similarity index for each channel of the image. This value is between zero and one, where one corresponds to perfect fit. Unfortunately, the many Gaussian blurring is quite costly, so while the PSNR may work in a real time like environment (24 frame per second) this will take significantly more than to accomplish similar performance results. 
+
+Therefore, the source code presented at the start of the tutorial will perform the PSNR measurement for each frame, and the SSIM only for the frames where the PSNR falls below an input value. For visualization purpose we show both images in an OpenCV window and print the PSNR and MSSIM values to the console. Expect to see something like:
+
+.. image:: images/outputVideoInput.png
+   :alt: A sample output
+   :align: center
+
+You may observe a runtime instance of this on the `YouTube here <https://www.youtube.com/watch?v=iOcNljutOgg>`_. 
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Video Input with OpenCV (Plus PSNR and MSSIM)" width="560" height="349" src="http://www.youtube.com/embed/iOcNljutOgg?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
diff --git a/doc/tutorials/images/calib3d.jpg b/doc/tutorials/images/calib3d.jpg
new file mode 100644
index 0000000000..c5226a9a1d
Binary files /dev/null and b/doc/tutorials/images/calib3d.jpg differ
diff --git a/doc/tutorials/images/calib3d.png b/doc/tutorials/images/calib3d.png
deleted file mode 100644
index 89c84a8bdf..0000000000
Binary files a/doc/tutorials/images/calib3d.png and /dev/null differ
diff --git a/doc/tutorials/images/core.jpg b/doc/tutorials/images/core.jpg
new file mode 100644
index 0000000000..6fe819bd52
Binary files /dev/null and b/doc/tutorials/images/core.jpg differ
diff --git a/doc/tutorials/images/core.png b/doc/tutorials/images/core.png
deleted file mode 100644
index 9e43df01ff..0000000000
Binary files a/doc/tutorials/images/core.png and /dev/null differ
diff --git a/doc/tutorials/images/feature2D.jpg b/doc/tutorials/images/feature2D.jpg
new file mode 100644
index 0000000000..6744de0610
Binary files /dev/null and b/doc/tutorials/images/feature2D.jpg differ
diff --git a/doc/tutorials/images/feature2D.png b/doc/tutorials/images/feature2D.png
deleted file mode 100644
index 429b493b0a..0000000000
Binary files a/doc/tutorials/images/feature2D.png and /dev/null differ
diff --git a/doc/tutorials/images/general.jpg b/doc/tutorials/images/general.jpg
new file mode 100644
index 0000000000..95829d9c64
Binary files /dev/null and b/doc/tutorials/images/general.jpg differ
diff --git a/doc/tutorials/images/general.png b/doc/tutorials/images/general.png
deleted file mode 100644
index 1910b7aff6..0000000000
Binary files a/doc/tutorials/images/general.png and /dev/null differ
diff --git a/doc/tutorials/images/gpu.jpg b/doc/tutorials/images/gpu.jpg
new file mode 100644
index 0000000000..4cc053895c
Binary files /dev/null and b/doc/tutorials/images/gpu.jpg differ
diff --git a/doc/tutorials/images/gpu.png b/doc/tutorials/images/gpu.png
deleted file mode 100644
index 0ad228439f..0000000000
Binary files a/doc/tutorials/images/gpu.png and /dev/null differ
diff --git a/doc/tutorials/images/highgui.jpg b/doc/tutorials/images/highgui.jpg
new file mode 100644
index 0000000000..ada65fcb03
Binary files /dev/null and b/doc/tutorials/images/highgui.jpg differ
diff --git a/doc/tutorials/images/highgui.png b/doc/tutorials/images/highgui.png
deleted file mode 100644
index 9dcf3446f8..0000000000
Binary files a/doc/tutorials/images/highgui.png and /dev/null differ
diff --git a/doc/tutorials/images/imgproc.jpg b/doc/tutorials/images/imgproc.jpg
new file mode 100644
index 0000000000..ad7dafb0b7
Binary files /dev/null and b/doc/tutorials/images/imgproc.jpg differ
diff --git a/doc/tutorials/images/imgproc.png b/doc/tutorials/images/imgproc.png
deleted file mode 100644
index 598a2c8952..0000000000
Binary files a/doc/tutorials/images/imgproc.png and /dev/null differ
diff --git a/doc/tutorials/images/introduction.jpg b/doc/tutorials/images/introduction.jpg
new file mode 100644
index 0000000000..19a9284785
Binary files /dev/null and b/doc/tutorials/images/introduction.jpg differ
diff --git a/doc/tutorials/images/introduction.png b/doc/tutorials/images/introduction.png
deleted file mode 100644
index 6fcc6a5883..0000000000
Binary files a/doc/tutorials/images/introduction.png and /dev/null differ
diff --git a/doc/tutorials/images/ml.jpg b/doc/tutorials/images/ml.jpg
new file mode 100644
index 0000000000..40acfcfbfd
Binary files /dev/null and b/doc/tutorials/images/ml.jpg differ
diff --git a/doc/tutorials/images/ml.png b/doc/tutorials/images/ml.png
deleted file mode 100644
index d99497f2f1..0000000000
Binary files a/doc/tutorials/images/ml.png and /dev/null differ
diff --git a/doc/tutorials/images/objdetect.jpg b/doc/tutorials/images/objdetect.jpg
new file mode 100644
index 0000000000..c811f348f5
Binary files /dev/null and b/doc/tutorials/images/objdetect.jpg differ
diff --git a/doc/tutorials/images/objdetect.png b/doc/tutorials/images/objdetect.png
deleted file mode 100644
index 03112694e3..0000000000
Binary files a/doc/tutorials/images/objdetect.png and /dev/null differ
diff --git a/doc/tutorials/images/video.jpg b/doc/tutorials/images/video.jpg
new file mode 100644
index 0000000000..dd5d0c4ed2
Binary files /dev/null and b/doc/tutorials/images/video.jpg differ
diff --git a/doc/tutorials/images/video.png b/doc/tutorials/images/video.png
deleted file mode 100644
index 69a925f31e..0000000000
Binary files a/doc/tutorials/images/video.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.rst b/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.rst
index aa7b7b30bd..601abb893b 100644
--- a/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.rst
+++ b/doc/tutorials/imgproc/erosion_dilatation/erosion_dilatation.rst
@@ -36,7 +36,6 @@ Morphological Operations
 
   .. image:: images/Morphology_1_Tutorial_Theory_Original_Image.png
      :alt: Original image
-     :height: 100px
      :align: center 
 
 Dilation
@@ -50,7 +49,6 @@ Dilation
 
   .. image:: images/Morphology_1_Tutorial_Theory_Dilation.png
      :alt: Dilation result - Theory example
-     :height: 100px
      :align: center 
 
 The background (bright) dilates around the black regions of the letter.
@@ -66,7 +64,6 @@ Erosion
 
   .. image:: images/Morphology_1_Tutorial_Theory_Erosion.png
      :alt: Erosion result - Theory example
-     :height: 100px
      :align: center 
 
 
@@ -266,15 +263,12 @@ Results
 
 * Compile the code above and execute it with an image as argument. For instance, using this image:
 
-  .. image:: images/Morphology_1_Tutorial_Original_Image.png
+  .. image:: images/Morphology_1_Tutorial_Original_Image.jpg
      :alt: Original image
-     :height: 200px
      :align: center 
 
   We get the results below. Varying the indices in the Trackbars give different output images, naturally. Try them out! You can even try to add a third Trackbar to control the number of iterations.
 
-  .. image:: images/Morphology_1_Tutorial_Cover.png
+  .. image:: images/Morphology_1_Tutorial_Cover.jpg
      :alt: Dilation and Erosion application
-     :height: 400px
-     :align: center 
- 
+     :align: center 
\ No newline at end of file
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.jpg b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..64de099f70
Binary files /dev/null and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.png
deleted file mode 100644
index 90e8c22c96..0000000000
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.jpg b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.jpg
new file mode 100644
index 0000000000..f5dcfcca0f
Binary files /dev/null and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.jpg differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.png
deleted file mode 100644
index 9c86e5fc9e..0000000000
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Dilation_Result.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.jpg b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.jpg
new file mode 100644
index 0000000000..bda78a60e7
Binary files /dev/null and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.jpg differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.png
deleted file mode 100644
index 501f7f84b1..0000000000
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Erosion_Result.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.jpg
new file mode 100644
index 0000000000..5b61a95527
Binary files /dev/null and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.png
deleted file mode 100644
index fafe56c249..0000000000
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Original_Image.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Dilation.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Dilation.png
index 475d9c72b6..dae930ec1e 100644
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Dilation.png and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Dilation.png differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Erosion.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Erosion.png
index da734dfb13..755561023f 100644
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Erosion.png and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Erosion.png differ
diff --git a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Original_Image.png b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Original_Image.png
index ed04720860..d7e8a9a429 100644
Binary files a/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Original_Image.png and b/doc/tutorials/imgproc/erosion_dilatation/images/Morphology_1_Tutorial_Theory_Original_Image.png differ
diff --git a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter.rst b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter.rst
index 6fc7012979..ef8500880b 100644
--- a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter.rst
+++ b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter.rst
@@ -6,77 +6,82 @@ Smoothing Images
 Goal
 =====
 
-In this tutorial you will learn how to:
+In this tutorial you will learn how to apply diverse linear filters to smooth images using OpenCV functions such as:
 
-* Apply diverse linear filters to smooth images using OpenCV functions such as:
+.. container:: enumeratevisibleitemswithsquare
 
-  * :blur:`blur <>`
-  * :gaussian_blur:`GaussianBlur <>`
-  * :median_blur:`medianBlur <>`
-  * :bilateral_filter:`bilateralFilter <>`
+   * :blur:`blur <>`
+   * :gaussian_blur:`GaussianBlur <>`
+   * :median_blur:`medianBlur <>`
+   * :bilateral_filter:`bilateralFilter <>`
 
-Cool Theory
-============
+Theory
+======
 
 .. note::
    The explanation below belongs to the book `Computer Vision: Algorithms and Applications <http://szeliski.org/Book/>`_  by Richard Szeliski and to *LearningOpenCV* 
 
-* *Smoothing*, also called *blurring*, is a simple and frequently used image processing operation. 
+.. container:: enumeratevisibleitemswithsquare
 
-* There are many reasons for smoothing. In this tutorial we will focus on smoothing in order to reduce noise (other uses will be seen in the following tutorials).
+   * *Smoothing*, also called *blurring*, is a simple and frequently used image processing operation. 
 
-* To perform a smoothing operation we will apply a *filter* to our image. The most common type of filters are *linear*, in which an output pixel's value (i.e. :math:`g(i,j)`) is determined as a weighted sum of input pixel values (i.e. :math:`f(i+k,j+l)`) :
+   * There are many reasons for smoothing. In this tutorial we will focus on smoothing in order to reduce noise (other uses will be seen in the following tutorials).
 
-  .. math::
-     g(i,j) = \sum_{k,l} f(i+k, j+l) h(k,l)
+   * To perform a smoothing operation we will apply a *filter* to our image. The most common type of filters are *linear*, in which an output pixel's value (i.e. :math:`g(i,j)`) is determined as a weighted sum of input pixel values (i.e. :math:`f(i+k,j+l)`) :
 
-  :math:`h(k,l)` is called the *kernel*, which is nothing more than the coefficients of the filter.
+     .. math::
+        g(i,j) = \sum_{k,l} f(i+k, j+l) h(k,l)
+
+     :math:`h(k,l)` is called the *kernel*, which is nothing more than the coefficients of the filter.
     
 
- It helps to visualize a *filter* as a window of coefficients sliding across the image.
+     It helps to visualize a *filter* as a window of coefficients sliding across the image.
 
-* There are many kind of filters, here we will mention the most used:
+   * There are many kind of filters, here we will mention the most used:
 
 Normalized Box Filter
 -----------------------
 
-* This filter is the simplest of all! Each output pixel is the *mean* of its kernel neighbors ( all of them contribute with equal weights) 
+.. container:: enumeratevisibleitemswithsquare
 
-* Just in case, the kernel is below:
+   * This filter is the simplest of all! Each output pixel is the *mean* of its kernel neighbors ( all of them contribute with equal weights) 
 
-.. math::
+   * The kernel is below:
+
+     .. math::
    
-   K = \dfrac{1}{K_{width} \cdot K_{height}} \begin{bmatrix}
-    1 & 1 & 1 & ... & 1 \\
-    1 & 1 & 1 & ... & 1 \\
-    . & . & . & ... & 1 \\
-    . & . & . & ... & 1 \\
-    1 & 1 & 1 & ... & 1
-   \end{bmatrix} 
+        K = \dfrac{1}{K_{width} \cdot K_{height}} \begin{bmatrix}
+            1 & 1 & 1 & ... & 1 \\
+            1 & 1 & 1 & ... & 1 \\
+            . & . & . & ... & 1 \\
+            . & . & . & ... & 1 \\
+            1 & 1 & 1 & ... & 1
+           \end{bmatrix} 
 
 
 Gaussian Filter
 ---------------
-* Probably the most useful filter (although not the fastest). Gaussian filtering is done by convolving each point in the input array with a *Gaussian kernel* and then summing them all to produce the output array.
 
-* Just to make the picture clearer, remember how a 1D Gaussian kernel look like?
+.. container:: enumeratevisibleitemswithsquare
 
-  .. image:: images/Smoothing_Tutorial_theory_gaussian_0.jpg
-             :height: 200px
-             :align: center 
+   * Probably the most useful filter (although not the fastest). Gaussian filtering is done by convolving each point in the input array with a *Gaussian kernel* and then summing them all to produce the output array.
 
-  Assuming that an image is 1D, you can notice that the pixel located in the middle would have the biggest weight. The weight of its neighbors decreases as the spatial distance between them and the center pixel increases. 
+   * Just to make the picture clearer, remember how a 1D Gaussian kernel look like?
+
+     .. image:: images/Smoothing_Tutorial_theory_gaussian_0.jpg
+              :align: center 
+
+     Assuming that an image is 1D, you can notice that the pixel located in the middle would have the biggest weight. The weight of its neighbors decreases as the spatial distance between them and the center pixel increases. 
 
 .. note::
 
-   * Remember that a 2D Gaussian can be represented as :
+   Remember that a 2D Gaussian can be represented as :
    
-     .. math::
+   .. math::
      
-        G_{0}(x, y) = A  e^{ \dfrac{ -(x - \mu_{x})^{2} }{ 2\sigma^{2}_{x} } +  \dfrac{ -(y - \mu_{y})^{2} }{ 2\sigma^{2}_{y} } }
-
-     where :math:`\mu` is the mean (the peak) and :math:`\sigma` represents the variance (per each of the variables :math:`x` and :math:`y`)
+      G_{0}(x, y) = A  e^{ \dfrac{ -(x - \mu_{x})^{2} }{ 2\sigma^{2}_{x} } +  \dfrac{ -(y - \mu_{y})^{2} }{ 2\sigma^{2}_{y} } }
 
+   where :math:`\mu` is the mean (the peak) and :math:`\sigma` represents the variance (per each of the variables :math:`x` and :math:`y`)
 
 
 Median Filter
@@ -88,19 +93,32 @@ The median filter run through each element of the signal (in this case the image
 Bilateral Filter
 -----------------
 
-* So far, we have explained some filters which main goal is to *smooth* an input image. However, sometimes the filters do not only dissolve the noise, but also smooth away the *edges*. To avoid this (at certain extent at least), we can use a bilateral filter.
+.. container:: enumeratevisibleitemswithsquare
 
-* In an analogous way as the Gaussian filter,  the bilateral filter also considers the neighboring pixels with  weights assigned to each of them. These weights have two components, the first of which is the same weighting used by the Gaussian filter. The second component takes into account the difference in intensity between the neighboring pixels and the evaluated one. 
-
-* For a more detailed explanation you can check `this link <http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html>`_  
+   * So far, we have explained some filters which main goal is to *smooth* an input image. However, sometimes the filters do not only dissolve the noise, but also smooth away the *edges*. To avoid this (at certain extent at least), we can use a bilateral filter.
 
+   * In an analogous way as the Gaussian filter,  the bilateral filter also considers the neighboring pixels with  weights assigned to each of them. These weights have two components, the first of which is the same weighting used by the Gaussian filter. The second component takes into account the difference in intensity between the neighboring pixels and the evaluated one. 
 
+   * For a more detailed explanation you can check `this link <http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html>`_  
 
 
 Code
 ======
 
-This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Image_Processing/Smoothing.cpp>`_
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads an image
+        * Applies 4 different kinds of filters (explained in Theory) and show the filtered images sequentially
+
+   * **Downloadable code**:
+     Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp>`_
+
+   * **Code at glance:**
+
 
 .. code-block:: cpp
 
@@ -130,7 +148,7 @@ This tutorial code's is shown lines below. You can also download it from `here <
       namedWindow( window_name, CV_WINDOW_AUTOSIZE );
 
       /// Load the source image
-      src = imread( "../images/lena.png", 1 ); 
+      src = imread( "../images/lena.jpg", 1 ); 
 
       if( display_caption( "Original Image" ) != 0 ) { return 0; }
 
@@ -198,7 +216,7 @@ This tutorial code's is shown lines below. You can also download it from `here <
 Explanation
 =============
 
-#. Let's check the OpenCV functions that involve only the smoothing procedure, since the rest is already known by now.
+#. Let's check the OpenCV functions that involve only the smoothing procedure, since the rest is already known by now. 
 
 #. **Normalized Block Filter:**
 
@@ -213,13 +231,15 @@ Explanation
 
    We specify 4 arguments (more details, check the Reference):
 
-   * *src*: Source image
+   .. container:: enumeratevisibleitemswithsquare
 
-   * *dst*: Destination image
+      + *src*: Source image
 
-   * *Size( w,h )*: Defines the size of the kernel to be used ( of width *w* pixels and height *h* pixels) 
+      + *dst*: Destination image
 
-   * *Point(-1, -1)*: Indicates where the anchor point (the pixel evaluated) is located with respect to the neighborhood. If there is a negative value, then the center of the kernel is considered the anchor point.  
+      + *Size( w,h )*: Defines the size of the kernel to be used ( of width *w* pixels and height *h* pixels) 
+
+      + *Point(-1, -1)*: Indicates where the anchor point (the pixel evaluated) is located with respect to the neighborhood. If there is a negative value, then the center of the kernel is considered the anchor point.  
     
 #. **Gaussian Filter:**
 
@@ -233,15 +253,17 @@ Explanation
 
    Here we use 4 arguments (more details, check the OpenCV reference):
 
-   * *src*: Source image
+   .. container:: enumeratevisibleitemswithsquare
 
-   * *dst*: Destination image
+      + *src*: Source image
 
-   * *Size(w, h)*: The size of the kernel to be used (the neighbors to be considered). :math:`w` and :math:`h` have to be odd and positive numbers otherwise thi size will be calculated using the :math:`\sigma_{x}` and :math:`\sigma_{y}` arguments.
+      + *dst*: Destination image
 
-   * :math:`\sigma_{x}`: The standard deviation in x. Writing :math:`0` implies that :math:`\sigma_{x}` is calculated using kernel size.
+      + *Size(w, h)*: The size of the kernel to be used (the neighbors to be considered). :math:`w` and :math:`h` have to be odd and positive numbers otherwise thi size will be calculated using the :math:`\sigma_{x}` and :math:`\sigma_{y}` arguments.
+
+      + :math:`\sigma_{x}`: The standard deviation in x. Writing :math:`0` implies that :math:`\sigma_{x}` is calculated using kernel size.
    
-   * :math:`\sigma_{y}`: The standard deviation in y. Writing :math:`0` implies that :math:`\sigma_{y}` is calculated using kernel size.
+      + :math:`\sigma_{y}`: The standard deviation in y. Writing :math:`0` implies that :math:`\sigma_{y}` is calculated using kernel size.
     
 
 #. **Median Filter:**
@@ -256,11 +278,13 @@ Explanation
 
    We use three arguments:
 
-   * *src*: Source image
+   .. container:: enumeratevisibleitemswithsquare
 
-   * *dst*: Destination image, must be the same type as *src*
+      + *src*: Source image
+
+      + *dst*: Destination image, must be the same type as *src*
    
-   * *i*: Size of the kernel (only one because we use a square window). Must be odd. 
+      + *i*: Size of the kernel (only one because we use a square window). Must be odd. 
 
 
 #. **Bilateral Filter**
@@ -275,24 +299,28 @@ Explanation
  
    We use 5 arguments:
 
-   * *src*: Source image
+   .. container:: enumeratevisibleitemswithsquare
 
-   * *dst*: Destination image
+      + *src*: Source image
 
-   * *d*: The diameter of each pixel neighborhood.
+      + *dst*: Destination image
+
+      + *d*: The diameter of each pixel neighborhood.
   
-   * :math:`\sigma_{Color}`: Standard deviation in the color space.
+      + :math:`\sigma_{Color}`: Standard deviation in the color space.
   
-   * :math:`\sigma_{Space}`: Standard deviation in the coordinate space (in pixel terms)
+      + :math:`\sigma_{Space}`: Standard deviation in the coordinate space (in pixel terms)
 
 
 Results
 ========
 
-* The code opens an image (in this case *lena.png*) and display it under the effects of the 4 filters explained. 
+.. container:: enumeratevisibleitemswithsquare
 
-* Here is a snapshot of the image smoothed using *medianBlur*:
+   * The code opens an image (in this case *lena.jpg*) and display it under the effects of the 4 filters explained. 
 
-  .. image:: images/Smoothing_Tutorial_Result_Median_Filter.png
-     :alt: Smoothing with a median filter
-     :align: center 
+   * Here is a snapshot of the image smoothed using *medianBlur*:
+
+     .. image:: images/Smoothing_Tutorial_Result_Median_Filter.jpg
+              :alt: Smoothing with a median filter
+              :align: center 
diff --git a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Cover.png b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Cover.png
deleted file mode 100644
index 45406171bf..0000000000
Binary files a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.jpg b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.jpg
new file mode 100644
index 0000000000..da5f1bac00
Binary files /dev/null and b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.jpg differ
diff --git a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.png b/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.png
deleted file mode 100644
index b8cf7ca224..0000000000
Binary files a/doc/tutorials/imgproc/gausian_median_blur_bilateral_filter/images/Smoothing_Tutorial_Result_Median_Filter.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/back_projection.rst b/doc/tutorials/imgproc/histograms/back_projection/back_projection.rst
new file mode 100644
index 0000000000..f6512f6c29
--- /dev/null
+++ b/doc/tutorials/imgproc/histograms/back_projection/back_projection.rst
@@ -0,0 +1,305 @@
+.. _back_projection:
+
+Back Projection
+****************
+
+
+Goal
+====
+
+In this tutorial you will learn:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * What is Back Projection and why it is useful
+
+   * How to use the OpenCV function :calc_back_project:`calcBackProject <>` to calculate Back Projection
+  
+   * How to mix different channels of an image by using the OpenCV function :mix_channels:`mixChannels <>`
+
+
+Theory
+======
+
+What is Back Projection?
+---------------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Back Projection is a way of recording how well the pixels of a given image fit the distribution of pixels in a histogram model.
+   
+   * To make it simpler: For Back Projection, you calculate the histogram model of a feature and then use it to find this feature in an image. 
+
+   * Application example: If you have a histogram of flesh color (say, a Hue-Saturation histogram ), then you can use it to find flesh color areas in an image:
+
+
+How does it work?
+------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * We explain this by using the skin example:
+
+   * Let's say you have gotten a skin histogram (Hue-Saturation) based on the image below. The histogram besides is going to be our *model histogram* (which we know represents a sample of skin tonality). You applied some mask to capture only the histogram of the skin area:
+
+     ======  ======  
+      |T0|    |T1|   
+     ======  ======   
+
+     .. |T0| image:: images/Back_Projection_Theory0.jpg
+                   :align: middle
+
+     .. |T1| image:: images/Back_Projection_Theory1.jpg
+                   :align: middle
+
+
+   * Now, let's imagine that you get another hand image (Test Image) like the one below: (with its respective histogram):
+
+     ======  ======  
+      |T2|    |T3|   
+     ======  ======   
+
+     .. |T2| image:: images/Back_Projection_Theory2.jpg
+                   :align: middle
+
+     .. |T3| image:: images/Back_Projection_Theory3.jpg
+                   :align: middle
+
+
+   * What we want to do is to use our *model histogram* (that we know represents a skin tonality) to detect skin areas in our Test Image. Here are the steps
+
+     a. In each pixel of our Test Image (i.e. :math:`p(i,j)` ), collect the data and find the correspondent bin location for that pixel (i.e. :math:`( h_{i,j}, s_{i,j} )` ).
+
+     b. Lookup the *model histogram* in the correspondent bin - :math:`( h_{i,j}, s_{i,j} )` - and read the bin value. 
+
+     c. Store this bin value in a new image (*BackProjection*). Also, you may consider to normalize the *model histogram* first, so the output for the Test Image can be visible for you.
+
+     d. Applying the steps above, we get the following BackProjection image for our Test Image:
+
+        .. image:: images/Back_Projection_Theory4.jpg
+                 :align: center
+
+     e. In terms of statistics, the values stored in *BackProjection* represent the *probability* that a pixel in *Test Image* belongs to a skin area, based on the *model histogram* that we use. For instance in our Test image, the brighter areas are more probable to be skin area (as they actually are), whereas the darker areas have less probability (notice that these "dark" areas belong to surfaces that have some shadow on it, which in turns affects the detection).
+
+
+Code
+====
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads an image
+        * Convert the original to HSV format and separate only *Hue* channel to be used for the Histogram (using the OpenCV function :mix_channels:`mixChannels <>`)
+        * Let the user to enter the number of bins to be used in the calculation of the histogram.
+	* Calculate the histogram (and update it if the bins change) and the backprojection of the same image.
+        * Display the backprojection and the histogram in windows.
+
+   * **Downloadable code**:
+
+      a. Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp>`_ for the basic version (explained in this tutorial). 
+      b. For stuff slightly fancier (using H-S histograms and floodFill to define a mask for the skin area) you can check the `improved demo <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp>`_ 
+      c. ...or you can always check out the classical `camshiftdemo <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/camshiftdemo.cpp>`_ in samples.
+
+   * **Code at glance:**
+
+.. code-block:: cpp
+
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include "opencv2/highgui/highgui.hpp"
+
+   #include <iostream>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global Variables
+   Mat src; Mat hsv; Mat hue; 
+   int bins = 25;
+
+   /// Function Headers
+   void Hist_and_Backproj(int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Read the image
+     src = imread( argv[1], 1 );
+     /// Transform it to HSV
+     cvtColor( src, hsv, CV_BGR2HSV );
+
+     /// Use only the Hue value
+     hue.create( hsv.size(), hsv.depth() );
+     int ch[] = { 0, 0 };
+     mixChannels( &hsv, 1, &hue, 1, ch, 1 );  
+
+     /// Create Trackbar to enter the number of bins
+     char* window_image = "Source image";
+     namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+     createTrackbar("* Hue  bins: ", window_image, &bins, 180, Hist_and_Backproj );
+     Hist_and_Backproj(0, 0);
+
+     /// Show the image
+     imshow( window_image, src );
+
+     /// Wait until user exits the program
+     waitKey(0);
+     return 0;  
+   }
+
+
+   /**
+    * @function Hist_and_Backproj
+    * @brief Callback to Trackbar
+    */
+   void Hist_and_Backproj(int, void* )
+   {
+     MatND hist;
+     int histSize = MAX( bins, 2 ); 
+     float hue_range[] = { 0, 180 };
+     const float* ranges = { hue_range };
+
+     /// Get the Histogram and normalize it
+     calcHist( &hue, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false );
+     normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+     /// Get Backprojection
+     MatND backproj;
+     calcBackProject( &hue, 1, 0, hist, backproj, &ranges, 1, true );
+ 
+     /// Draw the backproj
+     imshow( "BackProj", backproj );
+
+     /// Draw the histogram
+     int w = 400; int h = 400;
+     int bin_w = cvRound( (double) w / histSize ); 
+     Mat histImg = Mat::zeros( w, h, CV_8UC3 );
+
+     for( int i = 0; i < bins; i ++ )  
+        { rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ), Scalar( 0, 0, 255 ), -1 ); }
+
+     imshow( "Histogram", histImg );
+   }
+
+Explanation
+===========
+
+#. Declare the matrices to store our images and initialize the number of bins to be used by our histogram:
+
+   .. code-block:: cpp
+
+      Mat src; Mat hsv; Mat hue; 
+      int bins = 25;
+
+#. Read the input image and transform it to HSV format:
+
+   .. code-block:: cpp
+
+      src = imread( argv[1], 1 );
+      cvtColor( src, hsv, CV_BGR2HSV );
+
+#. For this tutorial, we will use only the Hue value for our 1-D histogram (check out the fancier code in the links above if you want to use the more standard H-S histogram, which yields better results):
+
+   .. code-block:: cpp
+
+      hue.create( hsv.size(), hsv.depth() );
+      int ch[] = { 0, 0 };
+      mixChannels( &hsv, 1, &hue, 1, ch, 1 );  
+
+   as you see, we use the function :mix_channels:`mixChannels` to get only the channel 0 (Hue) from the hsv image. It gets the following parameters:
+
+   .. container:: enumeratevisibleitemswithsquare
+
+      + **&hsv:** The source array from which the channels will be copied
+      + **1:** The number of source arrays
+      + **&hue:** The destination array of the copied channels  
+      + **1:** The number of destination arrays
+      + **ch[] = {0,0}:** The array of index pairs indicating how the channels are copied. In this case, the Hue(0) channel of &hsv is being copied to the 0 channel of &hue (1-channel)
+      + **1:** Number of index pairs 
+ 
+#. Create a Trackbar for the user to enter the bin values. Any change on the Trackbar means a call to the **Hist_and_Backproj** callback function.
+
+   .. code-block:: cpp
+  
+      char* window_image = "Source image";
+      namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+      createTrackbar("* Hue  bins: ", window_image, &bins, 180, Hist_and_Backproj );
+      Hist_and_Backproj(0, 0);
+
+#. Show the image and wait for the user to exit the program:
+
+   .. code-block:: cpp
+
+     imshow( window_image, src );
+
+     waitKey(0);
+     return 0;  
+
+#. **Hist_and_Backproj function:** Initialize the arguments needed for :calc_hist:`calcHist <>`. The number of bins comes from the Trackbar:
+
+
+   .. code-block:: cpp
+
+      void Hist_and_Backproj(int, void* )
+      {
+        MatND hist;
+        int histSize = MAX( bins, 2 ); 
+        float hue_range[] = { 0, 180 };
+        const float* ranges = { hue_range };
+
+#. Calculate the Histogram and normalize it to the range :math:`[0,255]`
+
+   .. code-block:: cpp
+
+      calcHist( &hue, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false );
+      normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+#. Get the Backprojection of the same image by calling the function :calc_back_project:`calcBackProject <>`
+
+   .. code-block:: cpp
+
+      MatND backproj;
+      calcBackProject( &hue, 1, 0, hist, backproj, &ranges, 1, true );
+
+   all the arguments are known (the same as used to calculate the histogram), only we add the backproj matrix, which will store the backprojection of the source image (&hue)
+ 
+#. Display backproj:
+
+   .. code-block:: cpp
+
+      imshow( "BackProj", backproj );
+
+#. Draw the 1-D Hue histogram of the image:
+
+   .. code-block:: cpp
+
+      int w = 400; int h = 400;
+      int bin_w = cvRound( (double) w / histSize ); 
+      Mat histImg = Mat::zeros( w, h, CV_8UC3 );
+
+      for( int i = 0; i < bins; i ++ )  
+         { rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ), Scalar( 0, 0, 255 ), -1 ); }
+
+      imshow( "Histogram", histImg );
+
+
+
+Results
+=======
+
+#. Here are the output by using a sample image ( guess what? Another hand ). You can play with the bin values and you will observe how it affects the results:
+
+   ======  ======  ======  
+    |R0|    |R1|    |R2|   
+   ======  ======  ====== 
+
+   .. |R0| image:: images/Back_Projection1_Source_Image.jpg
+                 :align: middle
+
+   .. |R1| image:: images/Back_Projection1_Histogram.jpg
+                 :align: middle
+
+   .. |R2| image:: images/Back_Projection1_BackProj.jpg
+                 :align: middle
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_BackProj.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_BackProj.jpg
new file mode 100644
index 0000000000..baf9cc28ec
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_BackProj.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Histogram.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Histogram.jpg
new file mode 100644
index 0000000000..b2d6a2dfbe
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Histogram.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Source_Image.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Source_Image.jpg
new file mode 100644
index 0000000000..21ed375fcf
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection1_Source_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_BackProj.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_BackProj.jpg
new file mode 100644
index 0000000000..5f3824ccfb
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_BackProj.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Mask.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Mask.jpg
new file mode 100644
index 0000000000..38cd4c8251
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Mask.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Source_Image.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Source_Image.jpg
new file mode 100644
index 0000000000..0c5c6f91d1
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection2_Source_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory0.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory0.jpg
new file mode 100644
index 0000000000..8d0ac9e4ab
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory0.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory1.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory1.jpg
new file mode 100644
index 0000000000..4107e5e976
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory1.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory2.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory2.jpg
new file mode 100644
index 0000000000..5f2b2f23dd
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory2.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory3.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory3.jpg
new file mode 100644
index 0000000000..cca1e81fda
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory3.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory4.jpg b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory4.jpg
new file mode 100644
index 0000000000..55ca013ba7
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/back_projection/images/Back_Projection_Theory4.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_calculation/histogram_calculation.rst b/doc/tutorials/imgproc/histograms/histogram_calculation/histogram_calculation.rst
new file mode 100644
index 0000000000..e8eb67f214
--- /dev/null
+++ b/doc/tutorials/imgproc/histograms/histogram_calculation/histogram_calculation.rst
@@ -0,0 +1,331 @@
+.. _histogram_calculation:
+
+Histogram Calculation
+*********************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :split:`split <>` to divide an image into its correspondent planes.
+
+   * To calculate histograms of arrays of images by using the OpenCV function :calc_hist:`calcHist <>`
+ 
+   * To normalize an array by using the function :normalize:`normalize <>`
+
+
+.. note::
+   In the last tutorial (:ref:`histogram_equalization`) we talked about a particular kind of histogram called *Image histogram*. Now we will considerate it in its more general concept. Read on!
+
+
+What are histograms?
+--------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Histograms are collected *counts* of data organized into a set of predefined *bins*
+
+   * When we say *data* we are not restricting it to be intensity values (as we saw in the previous Tutorial). The data collected can be whatever feature you find useful to describe your image.
+
+   * Let's see an example. Imagine that a Matrix contains information of an image (i.e. intensity in the range :math:`0-255`):
+
+
+     .. image:: images/Histogram_Calculation_Theory_Hist0.jpg
+              :align: center   
+
+   * What happens if we want to *count* this data in an organized way? Since we know that the *range* of information value for this case is 256 values, we can segment our range in subparts (called **bins**) like:
+
+     .. math::
+        \begin{array}{l}
+        [0, 255] = { [0, 15] \cup [16, 31] \cup ....\cup [240,255] } \\
+        range = { bin_{1} \cup bin_{2} \cup ....\cup bin_{n = 15} }
+        \end{array} 
+
+     and we can keep count of the number of pixels that fall in the range of each :math:`bin_{i}`. Applying this to the example above we get the image below ( axis x represents the bins and axis y the number of pixels in each of them).
+ 
+
+     .. image:: images/Histogram_Calculation_Theory_Hist1.jpg
+              :align: center 
+
+   * This was just a simple example of how an histogram works and why it is useful. An histogram can keep count not only of color intensities, but of whatever image features that we want to measure (i.e. gradients, directions, etc). 
+  
+   * Let's identify some parts of the histogram:
+
+     a. **dims**: The number of parameters you want to collect data of. In our example, **dims = 1** because we are only counting the intensity values of each pixel (in a greyscale image).
+     b. **bins**: It is the number of **subdivisions** in each dim. In our example, **bins = 16**
+     c. **range**: The limits for the values to be measured. In this case: **range = [0,255]** 
+     
+   * What if you want to count two features? In this case your resulting histogram would be a 3D plot (in which x and y would be :math:`bin_{x}` and :math:`bin_{y}` for each feature and z would be the number of counts for each combination of :math:`(bin_{x}, bin_{y})`. The same would apply for more features (of course it gets trickier).
+
+
+What OpenCV offers you
+-----------------------
+
+For simple purposes, OpenCV implements the function :calc_hist:`calcHist <>`, which calculates the histogram of a set of arrays (usually images or image planes). It can operate with up to 32 dimensions. We will see it in the code below!
+     
+
+Code
+====
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads an image
+        * Splits the image into its R, G and B planes using the function :split:`split <>`
+        * Calculate the Histogram of each 1-channel plane by calling the function :calc_hist:`calcHist <>`
+        * Plot the three histograms in a window
+
+   * **Downloadable code**:
+     Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp>`_
+
+   * **Code at glance:**
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream> 
+   #include <stdio.h>
+
+   using namespace std;
+   using namespace cv;
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     Mat src, dst;
+
+    /// Load image
+    src = imread( argv[1], 1 );
+
+    if( !src.data )
+      { return -1; }
+
+    /// Separate the image in 3 places ( R, G and B )
+    vector<Mat> rgb_planes;
+    split( src, rgb_planes ); 
+
+    /// Establish the number of bins 
+    int histSize = 255;
+
+    /// Set the ranges ( for R,G,B) )
+    float range[] = { 0, 255 } ; 
+    const float* histRange = { range };
+
+    bool uniform = true; bool accumulate = false;
+
+    Mat r_hist, g_hist, b_hist;
+
+    /// Compute the histograms:
+    calcHist( &rgb_planes[0], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );
+    calcHist( &rgb_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
+    calcHist( &rgb_planes[2], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
+
+    // Draw the histograms for R, G and B
+    int hist_w = 400; int hist_h = 400;
+    int bin_w = cvRound( (double) hist_w/histSize );
+
+    Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );
+
+    /// Normalize the result to [ 0, histImage.rows ]
+    normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+    normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+
+    /// Draw for each channel 
+    for( int i = 1; i < histSize; i++ )
+      { 
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) , 
+  		         Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), 
+	                 Scalar( 0, 0, 255), 2, 8, 0  ); 
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) , 
+		         Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ), 
+	                 Scalar( 0, 255, 0), 2, 8, 0  ); 
+        line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) , 
+		         Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), 
+	                 Scalar( 255, 0, 0), 2, 8, 0  );       
+       }
+
+    /// Display 
+    namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
+    imshow("calcHist Demo", histImage );
+
+    waitKey(0);
+
+    return 0;
+ 
+   }
+
+Explanation
+===========
+
+#. Create the necessary matrices:
+
+   .. code-block:: cpp
+
+      Mat src, dst;
+
+#. Load the source image
+
+   .. code-block:: cpp
+
+       src = imread( argv[1], 1 );
+
+       if( !src.data )
+         { return -1; }
+
+#. Separate the source image in its three R,G and B planes. For this we use the OpenCV function :split:`split <>`: 
+
+   .. code-block:: cpp
+
+      vector<Mat> rgb_planes;
+      split( src, rgb_planes ); 
+
+   our input is the image to be divided (this case with three channels) and the output is a vector of Mat )
+
+#. Now we are ready to start configuring the **histograms** for each plane. Since we are working with the R, G and B planes, we know that our values will range in the interval :math:`[0,255]`
+
+   a. Establish number of bins (5, 10...):
+
+      .. code-block:: cpp
+  
+         int histSize = 255;
+
+   b. Set the range of values (as we said, between 0 and 255 )
+
+      .. code-block:: cpp
+
+         /// Set the ranges ( for R,G,B) )
+         float range[] = { 0, 255 } ; 
+         const float* histRange = { range };
+
+   c. We want our bins to have the same size (uniform) and to clear the histograms in the beginning, so:
+
+      .. code-block:: cpp
+
+         bool uniform = true; bool accumulate = false;
+
+   d. Finally, we create the Mat objects to save our histograms. Creating 3 (one for each plane):
+
+      .. code-block:: cpp
+
+         Mat r_hist, g_hist, b_hist;
+
+   e. We proceed to calculate the histograms by using the OpenCV function :calc_hist:`calcHist <>`:
+   
+      .. code-block:: cpp
+
+         /// Compute the histograms:
+         calcHist( &rgb_planes[0], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );
+         calcHist( &rgb_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
+         calcHist( &rgb_planes[2], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
+   
+      where the arguments are:
+
+      .. container:: enumeratevisibleitemswithsquare
+        
+         + **&rgb_planes[0]:** The source array(s)
+         + **1**: The number of source arrays (in this case we are using 1. We can enter here also a list of arrays )
+         + **0**: The channel (*dim*) to be measured. In this case it is just the intensity (each array is single-channel) so we just write 0.
+         + **Mat()**: A mask to be used on the source array ( zeros indicating pixels to be ignored ). If not defined it is not used
+         + **r_hist**: The Mat object where the histogram will be stored
+         + **1**: The histogram dimensionality. 
+         + **histSize:** The number of bins per each used dimension  
+         + **histRange:** The range of values to be measured per each dimension
+         + **uniform** and **accumulate**: The bin sizes are the same and the histogram is cleared at the beginning.
+
+
+#. Create an image to display the histograms:
+
+   .. code-block:: cpp
+
+      // Draw the histograms for R, G and B
+      int hist_w = 400; int hist_h = 400;
+      int bin_w = cvRound( (double) hist_w/histSize );
+
+      Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );
+
+#. Notice that before drawing, we first :normalize:`normalize <>` the histogram  so its values fall in the range indicated by the parameters entered:
+
+   .. code-block:: cpp
+
+      /// Normalize the result to [ 0, histImage.rows ]
+      normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+      normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+      normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+
+   this function receives these arguments:
+
+   .. container:: enumeratevisibleitemswithsquare
+   
+      + **r_hist:** Input array
+      + **r_hist:** Output normalized array (can be the same)
+      + **0** and**histImage.rows**: For this example, they are the lower and upper limits to normalize the values of **r_hist**
+      + **NORM_MINMAX:** Argument that indicates the type of normalization (as described above, it adjusts the values between the two limits set before)
+      + **-1:** Implies that the output normalized array will be the same type as the input
+      + **Mat():** Optional mask
+
+#. Finally, observe that to access the bin (in this case in this 1D-Histogram):
+
+   .. code-block:: cpp
+
+      /// Draw for each channel 
+      for( int i = 1; i < histSize; i++ )
+        { 
+          line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) , 
+        	              Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), 
+	                      Scalar( 0, 0, 255), 2, 8, 0  ); 
+          line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) , 
+		              Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ), 
+	                      Scalar( 0, 255, 0), 2, 8, 0  ); 
+          line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) , 
+		              Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), 
+	                      Scalar( 255, 0, 0), 2, 8, 0  );       
+            }
+
+
+    we use the expression: 
+
+    .. code-block:: cpp
+
+       r_hist.at<float>(i)
+
+
+     where :math:`i` indicates the dimension. If it were a 2D-histogram we would use something like:
+
+    .. code-block:: cpp
+
+       r_hist.at<float>( i, j )
+
+
+#. Finally we display our histograms and wait for the user to exit:
+
+   .. code-block:: cpp
+
+      namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
+      imshow("calcHist Demo", histImage );
+
+      waitKey(0);
+
+      return 0;
+ 
+
+Result
+======
+
+#. Using as input argument an image like the shown below:
+
+     .. image:: images/Histogram_Calculation_Original_Image.jpg
+              :align: center   
+
+#. Produces the following histogram:
+
+     .. image:: images/Histogram_Calculation_Result.jpg
+              :align: center   
+
diff --git a/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Original_Image.jpg b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Original_Image.jpg
new file mode 100644
index 0000000000..d9da998b5c
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Result.jpg b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Result.jpg
new file mode 100644
index 0000000000..07b7e320d1
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Result.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist0.jpg b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist0.jpg
new file mode 100644
index 0000000000..07ba95dbbe
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist0.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist1.jpg b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist1.jpg
new file mode 100644
index 0000000000..7e420ba13b
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_calculation/images/Histogram_Calculation_Theory_Hist1.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_comparison/histogram_comparison.rst b/doc/tutorials/imgproc/histograms/histogram_comparison/histogram_comparison.rst
new file mode 100644
index 0000000000..5dbae046d3
--- /dev/null
+++ b/doc/tutorials/imgproc/histograms/histogram_comparison/histogram_comparison.rst
@@ -0,0 +1,299 @@
+.. _histogram_comparison:
+
+Histogram Comparison
+********************
+
+Goal
+====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the function :compare_hist:`compareHist <>` to get a numerical parameter that express how well two histograms match with each other.
+   * Use different metrics to compare histograms
+
+
+Theory
+======
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * To compare two histograms ( :math:`H_{1}` and :math:`H_{2}` ), first we have to choose a *metric* (:math:`d(H_{1}, H_{2})`) to express how well both histograms match.
+
+   * OpenCV implements the function :compare_hist:`compareHist <>` to perform a comparison. It also offers 4 different metrics to compute the matching:
+
+
+     a. **Correlation ( CV\_COMP\_CORREL )**
+        
+        .. math::
+    
+           d(H_1,H_2) =  \frac{\sum_I (H_1(I) - \bar{H_1}) (H_2(I) - \bar{H_2})}{\sqrt{\sum_I(H_1(I) - \bar{H_1})^2 \sum_I(H_2(I) - \bar{H_2})^2}} 
+    
+        where
+    
+        .. math::
+    
+           \bar{H_k} =  \frac{1}{N} \sum _J H_k(J) 
+    
+    
+        and :math:`N` is the total number of histogram bins.
+    
+    
+
+     b. **Chi-Square ( CV\_COMP\_CHISQR )**
+    
+        .. math::
+    
+           d(H_1,H_2) =  \sum _I  \frac{\left(H_1(I)-H_2(I)\right)^2}{H_1(I)+H_2(I)} 
+     
+    
+     c. **Intersection ( method=CV\_COMP\_INTERSECT )**
+    
+        .. math::
+    
+           d(H_1,H_2) =  \sum _I  \min (H_1(I), H_2(I))  
+    
+    
+     d. **Bhattacharyya distance ( CV\_COMP\_BHATTACHARYYA )**
+    
+        .. math::
+    
+           d(H_1,H_2) =  \sqrt{1 - \frac{1}{\sqrt{\bar{H_1} \bar{H_2} N^2}} \sum_I \sqrt{H_1(I) \cdot H_2(I)}} 
+    
+ 
+
+Code
+====
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads a *base image* and 2 *test images* to be compared with it.
+        * Generate 1 image that is the lower half of the *base image*
+        * Convert the images to HSV format
+        * Calculate the H-S histogram for all the images and normalize them in order to compare them.
+        * Compare the histogram of the *base image* with respect to the 2 test histograms, the histogram of the lower half base image and with the same base image histogram.
+        * Display the numerical matching parameters obtained.
+
+   * **Downloadable code**: 
+     Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp>`_ 
+
+   * **Code at glance:**
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace std;
+   using namespace cv;
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     Mat src_base, hsv_base;
+     Mat src_test1, hsv_test1;
+     Mat src_test2, hsv_test2;
+     Mat hsv_half_down;
+
+     /// Load three images with different environment settings
+     if( argc < 4 )
+       { printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
+         return -1; 
+       }
+
+     src_base = imread( argv[1], 1 );
+     src_test1 = imread( argv[2], 1 );
+     src_test2 = imread( argv[3], 1 );
+
+     /// Convert to HSV
+     cvtColor( src_base, hsv_base, CV_BGR2HSV );
+     cvtColor( src_test1, hsv_test1, CV_BGR2HSV );
+     cvtColor( src_test2, hsv_test2, CV_BGR2HSV );
+
+     hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );  
+
+     /// Using 30 bins for hue and 32 for saturation
+     int h_bins = 50; int s_bins = 60;
+     int histSize[] = { h_bins, s_bins };
+
+     // hue varies from 0 to 256, saturation from 0 to 180
+     float h_ranges[] = { 0, 256 };
+     float s_ranges[] = { 0, 180 };
+
+     const float* ranges[] = { h_ranges, s_ranges };
+
+     // Use the o-th and 1-st channels
+     int channels[] = { 0, 1 };
+
+     /// Histograms
+     MatND hist_base;
+     MatND hist_half_down;
+     MatND hist_test1;
+     MatND hist_test2;
+
+     /// Calculate the histograms for the HSV images
+     calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+     normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+     normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+     normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+     normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     /// Apply the histogram comparison methods
+     for( int i = 0; i < 4; i++ )
+        { int compare_method = i; 
+          double base_base = compareHist( hist_base, hist_base, compare_method );
+          double base_half = compareHist( hist_base, hist_half_down, compare_method );
+          double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+          double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+     
+          printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
+        } 
+
+     printf( "Done \n" );
+
+     return 0;
+    }
+
+
+Explanation
+===========
+
+#. Declare variables such as the matrices to store the base image and the two other images to compare ( RGB and HSV ) 
+
+   .. code-block:: cpp
+
+      Mat src_base, hsv_base;
+      Mat src_test1, hsv_test1;
+      Mat src_test2, hsv_test2;
+      Mat hsv_half_down;
+
+#. Load the base image (src\_base) and the other two test images:
+
+   .. code-block:: cpp
+
+      if( argc < 4 )
+        { printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
+          return -1; 
+        }
+
+      src_base = imread( argv[1], 1 );
+      src_test1 = imread( argv[2], 1 );
+      src_test2 = imread( argv[3], 1 );
+
+#. Convert them to HSV format:
+
+   .. code-block:: cpp
+
+      cvtColor( src_base, hsv_base, CV_BGR2HSV );
+      cvtColor( src_test1, hsv_test1, CV_BGR2HSV );
+      cvtColor( src_test2, hsv_test2, CV_BGR2HSV );
+
+#. Also, create an image of half the base image (in HSV format):
+
+   .. code-block:: cpp
+
+      hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );  
+
+#. Initialize the arguments to calculate the histograms (bins, ranges and channels H and S ).
+
+   .. code-block:: cpp
+
+     int h_bins = 50; int s_bins = 32;
+     int histSize[] = { h_bins, s_bins };
+
+     float h_ranges[] = { 0, 256 };
+     float s_ranges[] = { 0, 180 };
+
+     const float* ranges[] = { h_ranges, s_ranges };
+
+     int channels[] = { 0, 1 };
+
+#. Create the MatND objects to store the histograms:
+
+   .. code-block:: cpp
+
+      MatND hist_base;
+      MatND hist_half_down;
+      MatND hist_test1;
+      MatND hist_test2;
+
+#. Calculate the Histograms for the base image, the 2 test images and the half-down base image:
+
+   .. code-block:: cpp
+ 
+      calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+      normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+      calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+      normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+      calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+      normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+      calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+      normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+
+
+#. Apply sequentially the 4 comparison methods between the histogram of the base image (hist\_base) and the other histograms:
+
+   .. code-block:: cpp
+
+      for( int i = 0; i < 4; i++ )
+         { int compare_method = i; 
+           double base_base = compareHist( hist_base, hist_base, compare_method );
+           double base_half = compareHist( hist_base, hist_half_down, compare_method );
+           double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+           double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+     
+          printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
+        } 
+
+     
+Results
+========
+
+#. We use as input the following images:
+
+   ============  ============  ============ 
+    |Base_0|       |Test_1|      |Test_2|
+   ============  ============  ============ 
+
+   .. |Base_0| image:: images/Histogram_Comparison_Source_0.jpg
+                    :align: middle
+
+   .. |Test_1| image:: images/Histogram_Comparison_Source_1.jpg
+                      :align: middle
+
+   .. |Test_2| image:: images/Histogram_Comparison_Source_2.jpg
+                      :align: middle
+
+   where the first one is the base (to be compared to the others), the other 2 are the test images. We will also compare the first image with respect to itself and with respect of half the base image.
+
+#. We should expect a perfect match when we compare the base image histogram with itself. Also, compared with the histogram of half the base image, it should present a high match since both are from the same source. For the other two test images, we can observe that they have very different lighting conditions, so the matching should not be very good:
+
+#. Here the numeric results:
+
+  ===============   ===============  ===============  ===============  ===============
+  *Method*          Base - Base      Base - Half      Base - Test 1    Base - Test 2
+  ===============   ===============  ===============  ===============  ===============
+  *Correlation*     1.000000         0.930766         0.182073         0.120447 
+  *Chi-square*      0.000000         4.940466         21.184536        49.273437 
+  *Intersection*    24.391548        14.959809        3.889029         5.775088 
+  *Bhattacharyya*   0.000000         0.222609         0.646576         0.801869 
+  ===============   ===============  ===============  ===============  ===============
+
+
+  For the *Correlation* and *Intersection* methods, the higher the metric, the more accurate the match. As we can see, the match *base-base* is the highest of all as expected. Also we can observe that the match *base-half* is the second best match (as we predicted). For the other two metrics, the less the result, the better the match. We can observe that the matches between the test 1 and test 2 with respect to the base are worse, which again, was expected.
diff --git a/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_0.jpg b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_0.jpg
new file mode 100644
index 0000000000..8d0ac9e4ab
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_0.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_1.jpg b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_1.jpg
new file mode 100644
index 0000000000..2cafdaa48d
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_1.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_2.jpg b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_2.jpg
new file mode 100644
index 0000000000..2b783930eb
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_comparison/images/Histogram_Comparison_Source_2.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/histogram_equalization.rst b/doc/tutorials/imgproc/histograms/histogram_equalization/histogram_equalization.rst
new file mode 100644
index 0000000000..857002e8f7
--- /dev/null
+++ b/doc/tutorials/imgproc/histograms/histogram_equalization/histogram_equalization.rst
@@ -0,0 +1,217 @@
+.. _histogram_equalization:
+
+Histogram Equalization
+**********************
+
+Goal
+====
+
+In this tutorial you will learn:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * What an image histogram is and why it is useful
+
+   * To equalize histograms of images by using the OpenCV function:equalize_hist:`equalizeHist <>` 
+
+
+
+Theory
+======
+
+What is an Image Histogram?
+---------------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * It is a graphical representation of the intensity distribution of an image. 
+
+   * It quantifies the number of pixels for each intensity value considered.
+
+.. image:: images/Histogram_Equalization_Theory_0.jpg
+        :align: center 
+
+
+What is Histogram Equalization?
+-------------------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * It is a method that improves the contrast in an image, in order to stretch out the intensity range.
+
+   * To make it clearer, from the image above, you can see that the pixels seem clustered around the middle of the available range of intensities. What Histogram Equalization does is to *stretch out* this range. Take a look at the figure below: The green circles indicate the *underpopulated* intensities. After applying the equalization, we get an histogram like the figure in the center. The resulting image is shown in the picture at right.
+
+.. image:: images/Histogram_Equalization_Theory_1.jpg
+          :align: center 
+
+How does it work?
+-----------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Equalization implies *mapping* one distribution (the given histogram) to another distribution (a wider and more uniform distribution of intensity values) so the intensity values are spreaded over the whole range. 
+
+   * To accomplish the equalization effect, the remapping should be the *cumulative distribution function (cdf)* (more details, refer to *Learning OpenCV*). For the histogram :math:`H(i)`, its *cumulative distribution* :math:`H^{'}(i)` is:
+
+     .. math::
+
+        H^{'}(i) = \sum_{0 \le j < i} H(j) 
+
+     To use this as a remapping function, we have to normalize :math:`H^{'}(i)` such that the maximum value is 255 ( or the maximum value for the intensity of the image ). From the example above, the cumulative function is:
+
+     .. image:: images/Histogram_Equalization_Theory_2.jpg
+              :align: center 
+
+   * Finally, we use a simple remapping procedure to obtain the intensity values of the equalized image:
+
+     .. math::
+ 
+        equalized( x, y ) = H^{'}( src(x,y) )
+
+Code
+====
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads an image
+        * Convert the original image to grayscale 
+        * Equalize the Histogram by using the OpenCV function :equalize_hist:`EqualizeHist <>`
+        * Display the source and equalized images in a window.
+
+   * **Downloadable code**:
+     Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp>`_
+
+   * **Code at glance:**
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /**  @function main */
+   int main( int argc, char** argv )
+   {
+     Mat src, dst;
+
+     char* source_window = "Source image";
+     char* equalized_window = "Equalized Image";
+
+     /// Load image
+     src = imread( argv[1], 1 );
+
+     if( !src.data )
+       { cout<<"Usage: ./Histogram_Demo <path_to_image>"<<endl;
+         return -1;}
+
+     /// Convert to grayscale
+     cvtColor( src, src, CV_BGR2GRAY );
+
+     /// Apply Histogram Equalization
+     equalizeHist( src, dst );
+ 
+     /// Display results
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     namedWindow( equalized_window, CV_WINDOW_AUTOSIZE );
+
+     imshow( source_window, src );
+     imshow( equalized_window, dst );
+ 
+     /// Wait until user exits the program 
+     waitKey(0);
+
+     return 0;
+   }
+
+Explanation
+===========
+
+#. Declare the source and destination images as well as the windows names:  
+
+   .. code-block:: cpp
+
+      Mat src, dst;
+
+      char* source_window = "Source image";
+      char* equalized_window = "Equalized Image";
+
+#. Load the source image:
+ 
+   .. code-block:: cpp
+
+      src = imread( argv[1], 1 );
+
+      if( !src.data )
+        { cout<<"Usage: ./Histogram_Demo <path_to_image>"<<endl;
+          return -1;}
+
+#. Convert it to grayscale:
+
+   ..  code-block:: cpp
+
+       cvtColor( src, src, CV_BGR2GRAY );
+
+#. Apply histogram equalization with the function :equalize_hist:`equalizeHist <>` :
+
+   .. code-block:: cpp
+
+      equalizeHist( src, dst );
+ 
+   As it can  be easily seen, the only arguments are the original image and the output (equalized) image.
+
+#. Display both images (original and equalized) :
+
+   .. code-block::  cpp
+
+      namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+      namedWindow( equalized_window, CV_WINDOW_AUTOSIZE );
+
+      imshow( source_window, src );
+      imshow( equalized_window, dst );
+ 
+#. Wait until user exists the program
+     
+   .. code-block:: cpp
+
+      waitKey(0);
+      return 0;
+
+
+Results
+=======
+
+#. To appreciate better the results of equalization, let's introduce an image with not much contrast, such as:
+
+   .. image:: images/Histogram_Equalization_Original_Image.jpg
+            :align: center 
+
+   which, by the way, has this histogram:
+
+   .. image:: images/Histogram_Equalization_Original_Histogram.jpg
+            :align: center 
+
+   notice that the pixels are clustered around the center of the histogram.
+
+#. After applying the equalization with our program, we get this result:
+
+   .. image:: images/Histogram_Equalization_Equalized_Image.jpg
+            :align: center 
+
+   this image has certainly more contrast. Check out its new histogram like this:
+
+   .. image:: images/Histogram_Equalization_Equalized_Histogram.jpg
+            :align: center
+
+   Notice how the number of pixels is more distributed through the intensity range.
+
+
+.. note::
+   Are you wondering how did we draw the Histogram figures shown above? Check out the following tutorial!
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Histogram.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Histogram.jpg
new file mode 100644
index 0000000000..aa80cfa994
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Histogram.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Image.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Image.jpg
new file mode 100644
index 0000000000..70f885daf1
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Equalized_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Histogram.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Histogram.jpg
new file mode 100644
index 0000000000..a10e660b34
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Histogram.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Image.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Image.jpg
new file mode 100644
index 0000000000..cf5ddca8c5
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_0.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_0.jpg
new file mode 100644
index 0000000000..4f6257961e
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_1.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_1.jpg
new file mode 100644
index 0000000000..64b285ad85
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_1.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_2.jpg b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_2.jpg
new file mode 100644
index 0000000000..0a5695841e
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/histogram_equalization/images/Histogram_Equalization_Theory_2.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_0.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_0.jpg
new file mode 100644
index 0000000000..30b65ea923
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_0.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_1.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_1.jpg
new file mode 100644
index 0000000000..3e2128b8dd
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_1.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_2.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_2.jpg
new file mode 100644
index 0000000000..5427448699
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_2.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_3.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_3.jpg
new file mode 100644
index 0000000000..61e4a62f3e
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_3.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_4.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_4.jpg
new file mode 100644
index 0000000000..642764ed98
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_4.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_5.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_5.jpg
new file mode 100644
index 0000000000..845a4a91a0
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Correl_Result_5.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Image_Result.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Image_Result.jpg
new file mode 100644
index 0000000000..7eed84e5bc
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Image_Result.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Original_Image.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Original_Image.jpg
new file mode 100644
index 0000000000..7411ccb968
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Image.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Image.jpg
new file mode 100644
index 0000000000..5f0da4f06e
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Image.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Result.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Result.jpg
new file mode 100644
index 0000000000..c81afa1c3f
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Result.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Sliding.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Sliding.jpg
new file mode 100644
index 0000000000..7afeb00d7a
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Sliding.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Summary.jpg b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Summary.jpg
new file mode 100644
index 0000000000..ebb5ddb1d0
Binary files /dev/null and b/doc/tutorials/imgproc/histograms/template_matching/images/Template_Matching_Template_Theory_Summary.jpg differ
diff --git a/doc/tutorials/imgproc/histograms/template_matching/template_matching.rst b/doc/tutorials/imgproc/histograms/template_matching/template_matching.rst
new file mode 100644
index 0000000000..5d760bd217
--- /dev/null
+++ b/doc/tutorials/imgproc/histograms/template_matching/template_matching.rst
@@ -0,0 +1,372 @@
+.. _template_matching:
+
+Template Matching
+*****************
+
+Goal
+====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :match_template:`matchTemplate <>` to search for matches between an image patch and an input image
+   * Use the OpenCV function :min_max_loc:`minMaxLoc <>` to find the maximum and minimum values (as well as their positions) in a given array.
+
+Theory
+======
+
+What is template matching?
+--------------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   Template matching is a technique for finding areas of an image that match (are similar) to a template image (patch).
+
+
+How does it work?
+------------------
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * We need two primary components:
+
+     a. **Source image (I):** The image in which we expect to find a match to the template image 
+     b. **Template image (T):** The patch image which will be compared to the template image 
+
+     our goal is to detect the highest matching area:
+
+     .. image:: images/Template_Matching_Template_Theory_Summary.jpg
+              :align: center      
+
+   * To identify the matching area, we have to *compare* the template image against the source image by sliding it:
+
+     .. image:: images/Template_Matching_Template_Theory_Sliding.jpg
+              :align: center      
+
+   *  By **sliding**, we mean moving the patch one pixel at a time (left to right, up to down). At each location, a metric is calculated so it represents how "good" or "bad" the match at that location is (or how similar the patch is to that particular area of the source image).
+
+   *  For each location of **T** over **I**, you *store* the metric in the *result matrix* **(R)**. Each location :math:`(x,y)` in **R** contains the match metric:
+
+      .. image:: images/Template_Matching_Template_Theory_Result.jpg
+               :align: center      
+
+      the image above is the result **R** of sliding the patch with a metric **TM_CCORR_NORMED**. The brightest locations indicate the highest matches. As you can see, the location marked by the red circle is probably the one with the highest value, so that location (the rectangle formed by that point as a corner and width and height equal to the patch image) is considered the match. 
+
+   * In practice, we use the function :min_max_loc:`minMaxLoc <>` to locate the highest value (or lower, depending of the type of matching method) in the *R* matrix.
+   
+Which are the matching methods available in OpenCV?
+----------------------------------------------------
+
+Good question. OpenCV implements Template matching in the function :match_template:`matchTemplate <>`. The available methods are 6:
+
+a. **method=CV\_TM\_SQDIFF**
+        
+   .. math::
+    
+      R(x,y)= \sum _{x',y'} (T(x',y')-I(x+x',y+y'))^2  
+    
+    
+b. **method=CV\_TM\_SQDIFF\_NORMED**
+        
+   .. math::
+    
+      R(x,y)= \frac{\sum_{x',y'} (T(x',y')-I(x+x',y+y'))^2}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}} 
+       
+
+c. **method=CV\_TM\_CCORR**
+    
+   .. math::
+    
+      R(x,y)= \sum _{x',y'} (T(x',y')  \cdot I(x+x',y+y'))  
+      
+
+d. **method=CV\_TM\_CCORR\_NORMED**    
+    
+   .. math::
+    
+      R(x,y)= \frac{\sum_{x',y'} (T(x',y') \cdot I'(x+x',y+y'))}{\sqrt{\sum_{x',y'}T(x',y')^2 \cdot \sum_{x',y'} I(x+x',y+y')^2}} 
+    
+
+e. **method=CV\_TM\_CCOEFF**
+    
+   .. math::
+    
+      R(x,y)= \sum _{x',y'} (T'(x',y')  \cdot I(x+x',y+y'))  
+   
+   where
+     
+   .. math::
+    
+      \begin{array}{l} T'(x',y')=T(x',y') - 1/(w  \cdot h)  \cdot \sum _{x'',y''} T(x'',y'') \\ I'(x+x',y+y')=I(x+x',y+y') - 1/(w  \cdot h)  \cdot \sum _{x'',y''} I(x+x'',y+y'') \end{array} 
+    
+    
+f. **method=CV\_TM\_CCOEFF\_NORMED**
+    
+   .. math::
+    
+      R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} } 
+
+
+Code
+====
+
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * **What does this program do?**
+ 
+     .. container:: enumeratevisibleitemswithsquare
+
+        * Loads an input image and a image patch (*template*)
+        * Perform a template matching procedure by using the OpenCV function :match_template:`matchTemplate <>` with any of the 6 matching methods described before. The user can choose the method by entering its selection in the Trackbar.
+        * Normalize the output of the matching procedure
+        * Localize the location with higher matching probability
+        * Draw a rectangle around the area corresponding to the highest match
+
+   * **Downloadable code**:
+     Click `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp>`_
+
+   * **Code at glance:**
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp" 
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace std;
+   using namespace cv;
+
+   /// Global Variables
+   Mat img; Mat templ; Mat result;
+   char* image_window = "Source Image";
+   char* result_window = "Result window";
+
+   int match_method;
+   int max_Trackbar = 5;
+
+   /// Function Headers
+   void MatchingMethod( int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load image and template
+     img = imread( argv[1], 1 );
+     templ = imread( argv[2], 1 );
+
+     /// Create windows
+     namedWindow( image_window, CV_WINDOW_AUTOSIZE );
+     namedWindow( result_window, CV_WINDOW_AUTOSIZE );
+  
+     /// Create Trackbar
+     char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+     createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
+
+     MatchingMethod( 0, 0 );
+
+     waitKey(0);
+     return 0;
+   }
+
+   /**
+    * @function MatchingMethod
+    * @brief Trackbar callback
+    */
+   void MatchingMethod( int, void* )
+   {
+     /// Source image to display
+     Mat img_display;
+     img.copyTo( img_display );
+ 
+     /// Create the result matrix
+     int result_cols =  img.cols - templ.cols + 1;
+     int result_rows = img.rows - templ.rows + 1;   
+  
+     result.create( result_cols, result_rows, CV_32FC1 );
+
+     /// Do the Matching and Normalize
+     matchTemplate( img, templ, result, match_method );
+     normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
+
+     /// Localizing the best match with minMaxLoc
+     double minVal; double maxVal; Point minLoc; Point maxLoc;
+     Point matchLoc;
+ 
+     minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
+
+     /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better
+     if( match_method  == CV_TM_SQDIFF || match_method == CV_TM_SQDIFF_NORMED )
+       { matchLoc = minLoc; }
+     else  
+       { matchLoc = maxLoc; }
+
+     /// Show me what you got
+     rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+     rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+
+     imshow( image_window, img_display );
+     imshow( result_window, result );
+
+     return;
+   }
+
+Explanation
+===========
+
+#. Declare some global variables, such as the image, template and result matrices, as well as the match method and the window names:
+
+   .. code-block:: cpp
+
+      Mat img; Mat templ; Mat result;
+      char* image_window = "Source Image";
+      char* result_window = "Result window";
+
+      int match_method;
+      int max_Trackbar = 5;
+
+
+#. Load the source image and template:
+
+   .. code-block:: cpp
+
+      img = imread( argv[1], 1 );
+      templ = imread( argv[2], 1 );
+
+#. Create the windows to show the results:
+
+   .. code-block:: cpp
+
+      namedWindow( image_window, CV_WINDOW_AUTOSIZE );
+      namedWindow( result_window, CV_WINDOW_AUTOSIZE );
+  
+#. Create the Trackbar to enter the kind of matching method to be used. When a change is detected the callback function **MatchingMethod** is called.
+
+   .. code-block:: cpp
+
+      char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+      createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
+
+#. Wait until user exits the program.
+
+   .. code-block:: cpp
+
+      waitKey(0);
+      return 0;
+  
+#. Let's check out the callback function. First, it makes a copy of the source image:
+
+   .. code-block:: cpp
+
+     Mat img_display;
+     img.copyTo( img_display );
+
+
+#. Next, it creates the result matrix that will store the matching results for each template location. Observe in detail the size of the result matrix (which matches all possible locations for it)
+
+   .. code-block:: cpp
+ 
+      int result_cols =  img.cols - templ.cols + 1;
+      int result_rows = img.rows - templ.rows + 1;   
+  
+      result.create( result_cols, result_rows, CV_32FC1 );
+ 
+#. Perform the template matching operation:
+
+   .. code-block:: cpp
+
+     matchTemplate( img, templ, result, match_method );
+
+   the arguments are naturally the input image **I**, the template **T**, the result **R** and the match_method (given by the Trackbar)
+
+#. We normalize the results:
+
+   .. code-block:: cpp
+
+      normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
+
+#. We localize the minimum and maximum values in the result matrix **R** by using :min_max_loc:`minMaxLoc <>`. 
+
+   .. code-block:: cpp
+
+      double minVal; double maxVal; Point minLoc; Point maxLoc;
+      Point matchLoc;
+ 
+      minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
+   
+   the function calls as arguments:
+
+   .. container:: enumeratevisibleitemswithsquare   
+
+      + **result:** The source array
+      + **&minVal** and **&maxVal:** Variables to save the minimum and maximum values in **result**
+      + **&minLoc** and **&maxLoc:** The Point locations of the minimum and maximum values in the array.
+      + **Mat():** Optional mask
+
+
+#. For the first two methods ( CV\_SQDIFF and CV\_SQDIFF\_NORMED ) the best match are the lowest values. For all the others, higher values represent better matches. So, we save the corresponding value in the **matchLoc** variable:
+
+   .. code-block:: cpp
+     
+     if( match_method  == CV_TM_SQDIFF || match_method == CV_TM_SQDIFF_NORMED )
+       { matchLoc = minLoc; }
+     else  
+       { matchLoc = maxLoc; }
+
+#. Display the source image and the result matrix. Draw a rectangle around the highest possible matching area:
+
+   .. code-block:: cpp
+
+      rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+      rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+
+      imshow( image_window, img_display );
+      imshow( result_window, result );
+
+
+Results
+=======
+
+#. Testing our program with an input image such as:
+
+   .. image:: images/Template_Matching_Original_Image.jpg
+            :align: center
+ 
+   and a template image:
+
+   .. image:: images/Template_Matching_Template_Image.jpg
+            :align: center  
+
+#. Generate the following result matrices (first row are the standard methods SQDIFF, CCORR and CCOEFF, second row are the same methods in its normalized version). In the first column, the darkest is the better match, for the other two columns, the brighter a location, the higher the match.
+
+   ============  ============  ============ 
+    |Result_0|    |Result_2|    |Result_4|
+   ============  ============  ============ 
+    |Result_1|    |Result_3|    |Result_5|
+   ============  ============  ============ 
+
+   .. |Result_0| image:: images/Template_Matching_Correl_Result_0.jpg
+                      :align: middle
+
+   .. |Result_1| image:: images/Template_Matching_Correl_Result_1.jpg
+                      :align: middle
+
+   .. |Result_2| image:: images/Template_Matching_Correl_Result_2.jpg
+                      :align: middle
+
+   .. |Result_3| image:: images/Template_Matching_Correl_Result_3.jpg
+                      :align: middle
+
+   .. |Result_4| image:: images/Template_Matching_Correl_Result_4.jpg
+                      :align: middle
+
+   .. |Result_5| image:: images/Template_Matching_Correl_Result_5.jpg
+                      :align: middle
+
+#. The right match is shown below (black rectangle around the face of the guy at the right). Notice that CCORR and CCDEFF gave erroneous best matches, however their normalized version did it right, this may be due to the fact that we are only considering the "highest match" and not the other possible high matches.
+
+   .. image:: images/Template_Matching_Image_Result.jpg
+            :align: center
+
diff --git a/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.rst b/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.rst
index 1741111275..73a25382f6 100644
--- a/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.rst
+++ b/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.rst
@@ -27,12 +27,12 @@ Steps
    .. math::
    
       K = \dfrac{1}{159}\begin{bmatrix}
-			    2 & 4 & 5 & 4 & 2 \\
-			    4 & 9 & 12 & 9 & 4 \\
-			    5 & 12 & 15 & 12 & 5 \\
-			    4 & 9 & 12 & 9 & 4 \\
-			    2 & 4 & 5 & 4 & 2 
-              		    \end{bmatrix} 
+                2 & 4 & 5 & 4 & 2 \\
+                4 & 9 & 12 & 9 & 4 \\
+                5 & 12 & 15 & 12 & 5 \\
+                4 & 9 & 12 & 9 & 4 \\
+                2 & 4 & 5 & 4 & 2 
+                        \end{bmatrix} 
 
 
 #. Find the intensity gradient of the image. For this, we follow a procedure analogous to Sobel: 
@@ -206,7 +206,8 @@ Explanation
 #. Create a window to display the results
 
    .. code-block:: cpp
-     namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+      namedWindow( window_name, CV_WINDOW_AUTOSIZE );
 
 #. Create a Trackbar for the user to enter the lower threshold for our Canny detector:
 
diff --git a/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Original_Image.jpg
index b4545669fd..bf448f3c0f 100644
Binary files a/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Original_Image.jpg and b/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Result.jpg b/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Result.jpg
index bbddc716f6..21c8e1b35f 100644
Binary files a/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Result.jpg and b/doc/tutorials/imgproc/imgtrans/canny_detector/images/Canny_Detector_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/copyMakeBorder/copyMakeBorder.rst b/doc/tutorials/imgproc/imgtrans/copyMakeBorder/copyMakeBorder.rst
index a475dfb0da..5558b35013 100644
--- a/doc/tutorials/imgproc/imgtrans/copyMakeBorder/copyMakeBorder.rst
+++ b/doc/tutorials/imgproc/imgtrans/copyMakeBorder/copyMakeBorder.rst
@@ -1,4 +1,4 @@
-.. _copyMakeBorder:
+.. _copyMakeBorderTutorial:
 
 Adding borders to your images
 ******************************
diff --git a/doc/tutorials/imgproc/imgtrans/copyMakeBorder/images/CopyMakeBorder_Tutorial_Results.jpg b/doc/tutorials/imgproc/imgtrans/copyMakeBorder/images/CopyMakeBorder_Tutorial_Results.jpg
index 1c83dcb4c7..10c6c54159 100644
Binary files a/doc/tutorials/imgproc/imgtrans/copyMakeBorder/images/CopyMakeBorder_Tutorial_Results.jpg and b/doc/tutorials/imgproc/imgtrans/copyMakeBorder/images/CopyMakeBorder_Tutorial_Results.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/filter_2d/filter_2d.rst b/doc/tutorials/imgproc/imgtrans/filter_2d/filter_2d.rst
index 03e9148cf4..7fad4b56a7 100644
--- a/doc/tutorials/imgproc/imgtrans/filter_2d/filter_2d.rst
+++ b/doc/tutorials/imgproc/imgtrans/filter_2d/filter_2d.rst
@@ -132,6 +132,7 @@ Code
   
      return 0;
    }
+
 Explanation
 =============
 
@@ -193,6 +194,6 @@ Results
 
 #. After compiling the code above, you  can execute it giving as argument the path of an image. The result should be a window that shows an image blurred by a normalized filter. Each 0.5 seconds the kernel size should change, as can be seen in the series of snapshots below:
 
-   .. image:: images/filter_2d_tutorial_result.png
+   .. image:: images/filter_2d_tutorial_result.jpg
            :alt: kernel example
            :align: center
diff --git a/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_kernel_theory.png b/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_kernel_theory.png
index 70d4e2d210..4105288e64 100644
Binary files a/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_kernel_theory.png and b/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_kernel_theory.png differ
diff --git a/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.jpg b/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.jpg
new file mode 100644
index 0000000000..2cf9f5c16b
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.png b/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.png
deleted file mode 100644
index 416d84d98c..0000000000
Binary files a/doc/tutorials/imgproc/imgtrans/filter_2d/images/filter_2d_tutorial_result.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_circle/hough_circle.rst b/doc/tutorials/imgproc/imgtrans/hough_circle/hough_circle.rst
index 43f7cd0d74..bd90c0930e 100644
--- a/doc/tutorials/imgproc/imgtrans/hough_circle/hough_circle.rst
+++ b/doc/tutorials/imgproc/imgtrans/hough_circle/hough_circle.rst
@@ -1,178 +1,182 @@
-.. _hough_circle:
-
-Hough Circle Transform
-***********************
-
-Goal
-=====
-In this tutorial you will learn how to:
-
-* Use the OpenCV function :hough_circles:`HoughCircles <>` to detect circles in an image.
-
-Theory
-=======
-
-Hough Circle Transform
-------------------------
-
-* The Hough Circle Transform works in a *roughly* analogous way to the Hough Line Transform explained in the previous tutorial.
-* In the line detection case, a line was defined by two parameters :math:`(r, \theta)`. In the circle case, we need three parameters to define a circle:
- 
-  .. math::
-     
-     C : ( x_{center}, y_{center}, r ) 
-
-  where :math:`(x_{center}, y_{center})` define the center position (gree point) and :math:`r` is the radius, which allows us to completely define a circle, as it can be seen below:
-
-  .. image:: images/Hough_Circle_Tutorial_Theory_0.jpg
-          :alt: Result of detecting circles with Hough Transform
-          :height: 200pt
-          :align: center 
-
-* For sake of efficiency, OpenCV implements a detection method slightly trickier than the standard Hough Transform: *The Hough gradient method*. For more details, please check the book *Learning OpenCV* or your favorite Computer Vision bibliography
-
-Code
-======
-
-#. **What does this program do?**
- 
-   * Loads an image and blur it to reduce the noise
-   * Applies the *Hough Circle Transform* to the blurred image . 
-   * Display the detected circle in a window.
-
-#. The sample code that we will explain can be downloaded from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp>`_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found  `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp>`_
-
-.. code-block:: cpp 
-
-   #include "opencv2/highgui/highgui.hpp"
-   #include "opencv2/imgproc/imgproc.hpp"
-   #include <iostream>
-   #include <stdio.h>
-
-   using namespace cv;
-
-   /** @function main */
-   int main(int argc, char** argv)
-   {
-     Mat src, src_gray;
-
-     /// Read the image
-     src = imread( argv[1], 1 );
-
-     if( !src.data )
-       { return -1; }
-
-     /// Convert it to gray 
-     cvtColor( src, src_gray, CV_BGR2GRAY );
-
-     /// Reduce the noise so we avoid false circle detection
-     GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
-
-     vector<Vec3f> circles;
-
-     /// Apply the Hough Transform to find the circles
-     HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
-
-     /// Draw the circles detected
-     for( size_t i = 0; i < circles.size(); i++ )
-     {
-         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
-         int radius = cvRound(circles[i][2]);
-         // circle center
-         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
-         // circle outline
-         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
-      }
-
-     /// Show your results 
-     namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
-     imshow( "Hough Circle Transform Demo", src );
-
-     waitKey(0);
-     return 0;
-   }
-
-
-Explanation
-============
-
-
-#. Load an image
-
-   .. code-block:: cpp
-
-     src = imread( argv[1], 1 );
-
-     if( !src.data )
-       { return -1; }
-
-#. Convert it to grayscale:
-
-   .. code-block:: cpp
-
-      cvtColor( src, src_gray, CV_BGR2GRAY );
-
-#. Apply a Gaussian blur to reduce noise and avoid false circle detection:
-    
-   .. code-block::  cpp
-
-      GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
-
-#. Proceed to apply Hough Circle Transform:
-
-   .. code-block:: cpp
-
-      vector<Vec3f> circles;
-
-      HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
-
-   with the arguments:
-
-   * *src_gray*: Input image (grayscale)
-   * *circles*: A vector that stores sets of 3 values: :math:`x_{c}, y_{c}, r` for each detected circle.
-   * *CV_HOUGH_GRADIENT*: Define the detection method. Currently this is the only one available in OpenCV
-   * *dp = 1*: The inverse ratio of resolution
-   * *min_dist = src_gray.rows/8*: Minimum distance between detected centers
-   * *param_1 = 200*: Upper threshold for the internal Canny edge detector
-   * *param_2* = 100*: Threshold for center detection. 
-   * *min_radius = 0*: Minimum radio to be detected. If unknown, put zero as default. 
-   * *max_radius = 0*: Maximum radius to be detected. If unknown, put zero as default
-   
-#. Draw the detected circles:
-
-   .. code-block:: cpp
-
-      for( size_t i = 0; i < circles.size(); i++ )
-      {
-         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
-         int radius = cvRound(circles[i][2]);
-         // circle center
-         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
-         // circle outline
-         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
-       }	
-
-   You can see that we will draw the circle(s) on red and the center(s) with a small green dot
-
-#. Display the detected circle(s):
-
-   .. code-block:: cpp
-   
-      namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
-      imshow( "Hough Circle Transform Demo", src );
-
-#. Wait for the user to exit the program
-
-   .. code-block:: cpp
-
-      waitKey(0);
-
-
-Result
-=======
-
-The result of running the code above with a test image is shown below: 
-
-.. image:: images/Hough_Circle_Tutorial_Result.jpg
-   :alt: Result of detecting circles with Hough Transform
-   :align: center 
+.. _hough_circle:
+
+Hough Circle Transform
+***********************
+
+Goal
+=====
+In this tutorial you will learn how to:
+
+* Use the OpenCV function :hough_circles:`HoughCircles <>` to detect circles in an image.
+
+Theory
+=======
+
+Hough Circle Transform
+------------------------
+
+* The Hough Circle Transform works in a *roughly* analogous way to the Hough Line Transform explained in the previous tutorial.
+* In the line detection case, a line was defined by two parameters :math:`(r, \theta)`. In the circle case, we need three parameters to define a circle:
+ 
+  .. math::
+     
+     C : ( x_{center}, y_{center}, r ) 
+
+  where :math:`(x_{center}, y_{center})` define the center position (gree point) and :math:`r` is the radius, which allows us to completely define a circle, as it can be seen below:
+
+  .. image:: images/Hough_Circle_Tutorial_Theory_0.jpg
+          :alt: Result of detecting circles with Hough Transform
+          :align: center 
+
+* For sake of efficiency, OpenCV implements a detection method slightly trickier than the standard Hough Transform: *The Hough gradient method*. For more details, please check the book *Learning OpenCV* or your favorite Computer Vision bibliography
+
+Code
+======
+
+#. **What does this program do?**
+ 
+   * Loads an image and blur it to reduce the noise
+   * Applies the *Hough Circle Transform* to the blurred image . 
+   * Display the detected circle in a window.
+
+   .. |TutorialHoughCirclesSimpleDownload| replace:: here
+   .. _TutorialHoughCirclesSimpleDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp
+   .. |TutorialHoughCirclesFancyDownload| replace:: here
+   .. _TutorialHoughCirclesFancyDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
+
+#. The sample code that we will explain can be downloaded from |TutorialHoughCirclesSimpleDownload|_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found |TutorialHoughCirclesFancyDownload|_.
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace cv;
+
+   /** @function main */
+   int main(int argc, char** argv)
+   {
+     Mat src, src_gray;
+
+     /// Read the image
+     src = imread( argv[1], 1 );
+
+     if( !src.data )
+       { return -1; }
+
+     /// Convert it to gray 
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+
+     /// Reduce the noise so we avoid false circle detection
+     GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+
+     vector<Vec3f> circles;
+
+     /// Apply the Hough Transform to find the circles
+     HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
+
+     /// Draw the circles detected
+     for( size_t i = 0; i < circles.size(); i++ )
+     {
+         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+         int radius = cvRound(circles[i][2]);
+         // circle center
+         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
+         // circle outline
+         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
+      }
+
+     /// Show your results 
+     namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
+     imshow( "Hough Circle Transform Demo", src );
+
+     waitKey(0);
+     return 0;
+   }
+
+
+Explanation
+============
+
+
+#. Load an image
+
+   .. code-block:: cpp
+
+     src = imread( argv[1], 1 );
+
+     if( !src.data )
+       { return -1; }
+
+#. Convert it to grayscale:
+
+   .. code-block:: cpp
+
+      cvtColor( src, src_gray, CV_BGR2GRAY );
+
+#. Apply a Gaussian blur to reduce noise and avoid false circle detection:
+    
+   .. code-block::  cpp
+
+      GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+
+#. Proceed to apply Hough Circle Transform:
+
+   .. code-block:: cpp
+
+      vector<Vec3f> circles;
+
+      HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
+
+   with the arguments:
+
+   * *src_gray*: Input image (grayscale)
+   * *circles*: A vector that stores sets of 3 values: :math:`x_{c}, y_{c}, r` for each detected circle.
+   * *CV_HOUGH_GRADIENT*: Define the detection method. Currently this is the only one available in OpenCV
+   * *dp = 1*: The inverse ratio of resolution
+   * *min_dist = src_gray.rows/8*: Minimum distance between detected centers
+   * *param_1 = 200*: Upper threshold for the internal Canny edge detector
+   * *param_2* = 100*: Threshold for center detection. 
+   * *min_radius = 0*: Minimum radio to be detected. If unknown, put zero as default. 
+   * *max_radius = 0*: Maximum radius to be detected. If unknown, put zero as default
+   
+#. Draw the detected circles:
+
+   .. code-block:: cpp
+
+      for( size_t i = 0; i < circles.size(); i++ )
+      {
+         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+         int radius = cvRound(circles[i][2]);
+         // circle center
+         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
+         // circle outline
+         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
+       }	
+
+   You can see that we will draw the circle(s) on red and the center(s) with a small green dot
+
+#. Display the detected circle(s):
+
+   .. code-block:: cpp
+   
+      namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
+      imshow( "Hough Circle Transform Demo", src );
+
+#. Wait for the user to exit the program
+
+   .. code-block:: cpp
+
+      waitKey(0);
+
+
+Result
+=======
+
+The result of running the code above with a test image is shown below: 
+
+.. image:: images/Hough_Circle_Tutorial_Result.jpg
+   :alt: Result of detecting circles with Hough Transform
+   :align: center 
diff --git a/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Result.jpg b/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Result.jpg
index 2a599fc6ca..b05618478e 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Result.jpg and b/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Theory_0.jpg b/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Theory_0.jpg
index 8b729ca2fd..a09c46e1ea 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Theory_0.jpg and b/doc/tutorials/imgproc/imgtrans/hough_circle/images/Hough_Circle_Tutorial_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.rst b/doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.rst
index 9a717344f2..3d29793161 100644
--- a/doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.rst
+++ b/doc/tutorials/imgproc/imgtrans/hough_lines/hough_lines.rst
@@ -30,9 +30,8 @@ How does it work?
    b. In the **Polar coordinate system:** Parameters: :math:`(r,\theta)`
 
    .. image:: images/Hough_Lines_Tutorial_Theory_0.jpg
-      	   :alt: Line variables
-	   :height: 200pt
-   	   :align: center 
+      :alt: Line variables
+      :align: center 
 
    For Hough Transforms, we will express lines in the *Polar system*. Hence, a line equation can be written as: 
 
@@ -53,18 +52,17 @@ How does it work?
 #. If for a given :math:`(x_{0}, y_{0})` we plot the family of lines that goes through it, we get a sinusoid. For instance, for :math:`x_{0} = 8` and :math:`y_{0} = 6` we get the following plot (in a plane :math:`\theta` - :math:`r`):
 
    .. image:: images/Hough_Lines_Tutorial_Theory_1.jpg
-      	   :alt: Polar plot of a the family of lines of a point
-	   :height: 200pt
-   	   :align: center 
+      :alt: Polar plot of a the family of lines of a point
+      :align: center 
 
    We consider only points such that :math:`r > 0` and :math:`0< \theta < 2 \pi`. 
 
 #. We can do the same operation above for all the points in an image. If the curves of two different points intersect in the plane :math:`\theta` - :math:`r`, that means that both points belong to a same line. For instance, following with the example above and drawing the plot for two more points: :math:`x_{1} = 9`, :math:`y_{1} = 4` and :math:`x_{2} = 12`, :math:`y_{2} = 3`, we get:
 
    .. image:: images/Hough_Lines_Tutorial_Theory_2.jpg
-      	   :alt: Polar plot of the family of lines for three points
-	   :height: 200pt
-   	   :align: center 
+      :alt: Polar plot of the family of lines for three points
+      :align: center 
+
    The three plots intersect in one single point :math:`(0.925, 9.6)`, these coordinates are the parameters (:math:`\theta, r`) or the line in which :math:`(x_{0}, y_{0})`, :math:`(x_{1}, y_{1})` and :math:`(x_{2}, y_{2})` lay. 
 
 #. What does all the stuff above mean? It means that in general, a line can be *detected* by finding the number of intersections between curves.The more curves intersecting means that the line represented by that intersection have more points. In general, we can define a *threshold* of the minimum number of intersections needed to *detect* a line.
@@ -90,13 +88,19 @@ b. **The Probabilistic Hough Line Transform**
 Code
 ======
 
+.. |TutorialHoughLinesSimpleDownload| replace:: here
+.. _TutorialHoughLinesSimpleDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp
+.. |TutorialHoughLinesFancyDownload| replace:: here
+.. _TutorialHoughLinesFancyDownload: https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
+
+
 #. **What does this program do?**
  
    * Loads an image
    * Applies either a *Standard Hough Line Transform* or a *Probabilistic Line Transform*. 
    * Display the original image and the detected line in two windows.
 
-#. The sample code that we will explain can be downloaded from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/houghlines.cpp>`_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found  `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp>`_
+#. The sample code that we will explain can be downloaded from  |TutorialHoughLinesSimpleDownload|_. A slightly fancier version (which shows both Hough standard and probabilistic with trackbars for changing the threshold values) can be found  |TutorialHoughLinesFancyDownload|_.
 
 .. code-block:: cpp 
 
@@ -112,12 +116,12 @@ Code
    {
     cout << "\nThis program demonstrates line finding with the Hough transform.\n"
             "Usage:\n"
-            "./houghlines <image_name>, Default is pic1.png\n" << endl;
+            "./houghlines <image_name>, Default is pic1.jpg\n" << endl;
    }
 
    int main(int argc, char** argv)
    {
-    const char* filename = argc >= 2 ? argv[1] : "pic1.png";
+    const char* filename = argc >= 2 ? argv[1] : "pic1.jpg";
 
     Mat src = imread(filename, 0);
     if(src.empty())
@@ -276,14 +280,14 @@ Result
 Using an input image such as:
 
 .. image:: images/Hough_Lines_Tutorial_Original_Image.jpg
-        :alt: Result of detecting lines with Hough Transform
-        :align: center 
+   :alt: Result of detecting lines with Hough Transform
+   :align: center 
  
 We get the following result by using the Probabilistic Hough Line Transform:
 
 .. image:: images/Hough_Lines_Tutorial_Result.jpg
-        :alt: Result of detecting lines with Hough Transform
-        :align: center 
+   :alt: Result of detecting lines with Hough Transform
+   :align: center 
 
 You may observe that the number of lines detected vary while you change the *threshold*. The explanation is sort of evident: If you establish a higher threshold, fewer lines will be detected (since you will need more points to declare a line detected). 
 
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Original_Image.jpg
index 2e6211dbd3..ec75831989 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Original_Image.jpg and b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Result.jpg b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Result.jpg
index a6107b02b5..125437d8e8 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Result.jpg and b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_0.jpg b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_0.jpg
index e8111eb42e..0e0ff22ca1 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_0.jpg and b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_1.jpg b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_1.jpg
index 0f297046c5..edbbcf65c8 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_1.jpg and b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_1.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_2.jpg b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_2.jpg
index ae0dc05122..996f7c6e50 100644
Binary files a/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_2.jpg and b/doc/tutorials/imgproc/imgtrans/hough_lines/images/Hough_Lines_Tutorial_Theory_2.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Original_Image.jpg
index 2369ba57ce..beb114c7b5 100644
Binary files a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Original_Image.jpg and b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Result.jpg b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Result.jpg
index 2354d9a5db..9cba13315b 100644
Binary files a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Result.jpg and b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_Previous.jpg b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_Previous.jpg
index 1d5a29d8ba..6a16926e39 100644
Binary files a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_Previous.jpg and b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_Previous.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_ddIntensity.jpg b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_ddIntensity.jpg
index 7bc1768b0a..67d95d237a 100644
Binary files a/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_ddIntensity.jpg and b/doc/tutorials/imgproc/imgtrans/laplace_operator/images/Laplace_Operator_Tutorial_Theory_ddIntensity.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/laplace_operator/laplace_operator.rst b/doc/tutorials/imgproc/imgtrans/laplace_operator/laplace_operator.rst
index b7a8ee7519..99bb326ac5 100644
--- a/doc/tutorials/imgproc/imgtrans/laplace_operator/laplace_operator.rst
+++ b/doc/tutorials/imgproc/imgtrans/laplace_operator/laplace_operator.rst
@@ -19,14 +19,12 @@ Theory
 
    .. image:: images/Laplace_Operator_Tutorial_Theory_Previous.jpg
            :alt: Previous theory
-           :height: 200pt
            :align: center
 
 #. And...what happens if we take the second derivative?
 
    .. image:: images/Laplace_Operator_Tutorial_Theory_ddIntensity.jpg
            :alt: Second derivative
-           :height: 200pt
            :align: center
 
    You can observe that the second derivative is zero! So, we can also use this criterion to attempt to detect edges in an image. However, note that zeros will not only appear in edges (they can actually appear in other meaningless locations); this can be solved by applying filtering where needed.
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Original_Image.jpg
new file mode 100644
index 0000000000..422ce19dbb
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_0.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_0.jpg
new file mode 100644
index 0000000000..5020931d86
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_1.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_1.jpg
new file mode 100644
index 0000000000..e601fdfe57
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_1.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_2.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_2.jpg
new file mode 100644
index 0000000000..f597d49292
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_2.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_3.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_3.jpg
new file mode 100644
index 0000000000..fabfaf0569
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Result_3.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_0.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_0.jpg
new file mode 100644
index 0000000000..e58669623e
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_1.jpg b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_1.jpg
new file mode 100644
index 0000000000..7195da79c3
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/remap/images/Remap_Tutorial_Theory_1.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/remap/remap.rst b/doc/tutorials/imgproc/imgtrans/remap/remap.rst
new file mode 100644
index 0000000000..61e7048ea2
--- /dev/null
+++ b/doc/tutorials/imgproc/imgtrans/remap/remap.rst
@@ -0,0 +1,314 @@
+.. _remap:
+
+Remapping
+*********
+
+Goal
+====
+
+In this tutorial you will learn how to:
+
+a. Use the OpenCV function :remap:`remap <>` to implement simple remapping routines.
+
+Theory
+======
+
+What is remapping?
+------------------
+
+* It is the process of taking pixels from one place in the image and locating them in  another position in a new image. 
+
+* To accomplish the mapping process, it might be necessary to do some interpolation for non-integer pixel locations, since there will not always be a one-to-one-pixel correspondence between source and destination images.
+
+* We can express the remap for every pixel location :math:`(x,y)` as:
+
+  .. math::
+  
+     g(x,y) = f ( h(x,y) )
+
+  where :math:`g()` is the remapped image, :math:`f()` the source image and :math:`h(x,y)` is the mapping function that operates on :math:`(x,y)`.
+
+* Let's think in a quick example. Imagine that we have an image :math:`I` and, say, we want to do  a remap such that:
+
+  .. math::
+
+     h(x,y) = (I.cols - x, y )
+
+  What would happen? It is easily seen that the image would flip in the :math:`x` direction. For instance,  consider the input image: 
+
+  .. image:: images/Remap_Tutorial_Theory_0.jpg
+           :alt: Original test image
+           :width: 120pt
+           :align: center
+
+  observe how the red circle changes positions with respect to x (considering :math:`x` the horizontal direction):
+
+  .. image:: images/Remap_Tutorial_Theory_1.jpg
+           :alt: Original test image
+           :width: 120pt
+           :align: center
+
+* In OpenCV, the function :remap:`remap <>` offers a simple remapping implementation.
+
+Code
+====
+
+#. **What does this program do?**
+ 
+   * Loads an image
+   * Each second, apply 1 of 4 different remapping processes to the image and display them indefinitely in a window.
+   * Wait for the user to exit the program
+ 
+#. The tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp>`_
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace cv;
+
+   /// Global variables
+   Mat src, dst;
+   Mat map_x, map_y;
+   char* remap_window = "Remap demo";
+   int ind = 0;
+
+   /// Function Headers
+   void update_map( void );
+
+   /**
+   * @function main
+   */
+   int main( int argc, char** argv )
+   {
+     /// Load the image
+     src = imread( argv[1], 1 );
+
+    /// Create dst, map_x and map_y with the same size as src:
+    dst.create( src.size(), src.type() );
+    map_x.create( src.size(), CV_32FC1 );
+    map_y.create( src.size(), CV_32FC1 );
+  
+    /// Create window
+    namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
+
+    /// Loop
+    while( true )
+    {
+      /// Each 1 sec. Press ESC to exit the program
+      int c = waitKey( 1000 );
+
+      if( (char)c == 27 )
+        { break; }
+
+      /// Update map_x & map_y. Then apply remap
+      update_map();
+      remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) ); 
+
+      /// Display results
+      imshow( remap_window, dst );
+    }
+    return 0;
+   }
+
+   /**
+   * @function update_map
+   * @brief Fill the map_x and map_y matrices with 4 types of mappings
+   */
+   void update_map( void )
+   {
+     ind = ind%4;
+
+     for( int j = 0; j < src.rows; j++ )
+     { for( int i = 0; i < src.cols; i++ )
+ 	 {
+           switch( ind )
+	   {   
+	     case 0:
+	       if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )
+                 {
+	           map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;
+	           map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;
+	          }
+	       else
+		 { map_x.at<float>(j,i) = 0 ;
+	           map_y.at<float>(j,i) = 0 ;
+                 }
+                   break;
+	     case 1:
+	           map_x.at<float>(j,i) = i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+             case 2:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = j ;
+		   break;
+             case 3:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+           } // end of switch
+	 }
+      }
+    ind++;
+  }
+
+Explanation
+===========
+
+#. Create some variables we will use:
+
+   .. code-block:: cpp
+
+      Mat src, dst;
+      Mat map_x, map_y;
+      char* remap_window = "Remap demo";
+      int ind = 0;
+
+#. Load an image:
+   
+   .. code-block:: cpp
+
+      src = imread( argv[1], 1 );
+
+#. Create the destination image and the two mapping matrices (for x and y )
+
+   .. code-block:: cpp
+
+      dst.create( src.size(), src.type() );
+      map_x.create( src.size(), CV_32FC1 );
+      map_y.create( src.size(), CV_32FC1 );
+  
+#. Create a window to  display results
+
+   .. code-block:: cpp
+
+      namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
+
+#. Establish a loop. Each 1000 ms we update our mapping matrices (*mat_x* and *mat_y*) and apply them to our source image:
+   
+   .. code-block:: cpp
+
+      while( true )
+      {
+        /// Each 1 sec. Press ESC to exit the program
+        int c = waitKey( 1000 );
+
+        if( (char)c == 27 )
+          { break; }
+
+        /// Update map_x & map_y. Then apply remap
+        update_map();
+        remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) ); 
+
+        /// Display results
+        imshow( remap_window, dst );
+      }
+
+   The function that applies the remapping is :remap:`remap <>`. We give the following arguments:
+ 
+   * **src**: Source image
+   * **dst**: Destination image of same size as *src*
+   * **map_x**: The mapping function in the x direction. It is equivalent to the first component of :math:`h(i,j)`
+   * **map_y**: Same as above, but in y direction. Note that *map_y* and *map_x* are both of the same size as *src*
+   * **CV_INTER_LINEAR**: The type of interpolation to use for non-integer pixels. This is by default. 
+   * **BORDER_CONSTANT**: Default
+
+   How do we update our mapping matrices *mat_x* and *mat_y*? Go on reading:
+
+#. **Updating the mapping matrices:**  We are going to perform 4 different mappings:
+
+   a. Reduce the picture to half its size and will display it in the middle:
+
+      .. math::
+
+         h(i,j) = ( 2*i - src.cols/2  + 0.5, 2*j - src.rows/2  + 0.5) 
+
+      for all pairs :math:`(i,j)` such that: :math:`\dfrac{src.cols}{4}<i<\dfrac{3 \cdot src.cols}{4}`  and  :math:`\dfrac{src.rows}{4}<j<\dfrac{3 \cdot src.rows}{4}`		
+ 
+   b. Turn the image upside down: :math:`h( i, j ) = (i, src.rows - j)`
+       
+   c. Reflect the image from left to right: :math:`h(i,j) = ( src.cols - i, j )`
+
+   d. Combination of b and c: :math:`h(i,j) = ( src.cols - i, src.rows - j )`
+
+  This is expressed in the following snippet. Here, *map_x* represents the first coordinate of *h(i,j)* and *map_y* the second coordinate.
+  
+  .. code-block:: cpp
+
+     for( int j = 0; j < src.rows; j++ )
+     { for( int i = 0; i < src.cols; i++ )
+ 	 {
+           switch( ind )
+	   {   
+	     case 0:
+	       if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )
+                 {
+	           map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;
+	           map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;
+	          }
+	       else
+		 { map_x.at<float>(j,i) = 0 ;
+	           map_y.at<float>(j,i) = 0 ;
+                 }
+                   break;
+	     case 1:
+	           map_x.at<float>(j,i) = i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+             case 2:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = j ;
+		   break;
+             case 3:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+           } // end of switch
+	 }
+       }
+      ind++;
+     }
+
+
+Result
+======
+
+#. After compiling the code above, you can execute it giving as argument an image path. For instance, by using the following image:
+
+   .. image:: images/Remap_Tutorial_Original_Image.jpg
+            :alt: Original test image
+            :width: 250pt
+            :align: center
+
+#. This is the result of reducing it to half the size and centering it:
+
+   .. image:: images/Remap_Tutorial_Result_0.jpg
+            :alt: Result 0 for remapping
+            :width: 250pt
+            :align: center
+
+#. Turning it upside down:
+ 
+   .. image:: images/Remap_Tutorial_Result_1.jpg
+            :alt: Result 0 for remapping
+            :width: 250pt
+            :align: center
+
+#. Reflecting it in the x direction:
+
+   .. image:: images/Remap_Tutorial_Result_2.jpg
+            :alt: Result 0 for remapping
+            :width: 250pt
+            :align: center
+
+#. Reflecting it in both directions:
+
+.. image:: images/Remap_Tutorial_Result_3.jpg
+         :alt: Result 0 for remapping
+         :width: 250pt
+         :align: center
+
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Result.jpg b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Result.jpg
index ead594e5eb..45f44b8cd5 100644
Binary files a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Result.jpg and b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_0.jpg b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_0.jpg
index c79d50634a..2c84310632 100644
Binary files a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_0.jpg and b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg
index bd77398107..adaab86673 100644
Binary files a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg and b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg
index ce43af116c..3a5b13a3f9 100644
Binary files a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg and b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_ddIntensity_Function.jpg b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_ddIntensity_Function.jpg
index 7bc1768b0a..3fae177233 100644
Binary files a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_ddIntensity_Function.jpg and b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/images/Sobel_Derivatives_Tutorial_Theory_ddIntensity_Function.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/sobel_derivatives.rst b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/sobel_derivatives.rst
index 4b504a8c20..d544b109cd 100644
--- a/doc/tutorials/imgproc/imgtrans/sobel_derivatives/sobel_derivatives.rst
+++ b/doc/tutorials/imgproc/imgtrans/sobel_derivatives/sobel_derivatives.rst
@@ -26,7 +26,6 @@ Theory
 
    .. image:: images/Sobel_Derivatives_Tutorial_Theory_0.jpg
            :alt: How intensity changes in an edge
-           :height: 200pt
            :align: center
  
    You can easily notice that in an *edge*, the pixel intensity *changes* in a notorious way. A good way to express *changes* is by using *derivatives*. A high change in gradient indicates a major change in the image. 
@@ -35,14 +34,12 @@ Theory
 
    .. image:: images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg
            :alt:  Intensity Plot for an edge
-           :height: 200pt
            :align: center
 
 #. The edge "jump" can be seen more easily if we take the first derivative (actually, here appears as a maximum)
 
    .. image:: images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg
            :alt:  First derivative of Intensity - Plot for an edge
-           :height: 200pt
            :align: center
 
 #. So, from the explanation above, we can deduce that a method to detect edges in an image can be performed by locating pixel locations where the gradient is higher than its neighbors (or to generalize, higher than a threshold).
@@ -231,6 +228,7 @@ Explanation
       Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );   
       /// Gradient Y  
       Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );   
+
    The function takes the following arguments:
 
    * *src_gray*: In our example, the input image. Here it is *CV_8U* 
diff --git a/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Original_Image.jpg
new file mode 100644
index 0000000000..6c1c77341b
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp.jpg b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp.jpg
new file mode 100644
index 0000000000..8fa7d65c4c
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp_Rotate.jpg b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp_Rotate.jpg
new file mode 100644
index 0000000000..1f828309ff
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Result_Warp_Rotate.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Theory_0.jpg b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Theory_0.jpg
new file mode 100644
index 0000000000..8294823bd8
Binary files /dev/null and b/doc/tutorials/imgproc/imgtrans/warp_affine/images/Warp_Affine_Tutorial_Theory_0.jpg differ
diff --git a/doc/tutorials/imgproc/imgtrans/warp_affine/warp_affine.rst b/doc/tutorials/imgproc/imgtrans/warp_affine/warp_affine.rst
new file mode 100644
index 0000000000..774ef281ed
--- /dev/null
+++ b/doc/tutorials/imgproc/imgtrans/warp_affine/warp_affine.rst
@@ -0,0 +1,309 @@
+.. _warp_affine:
+
+Affine Transformations
+**********************
+
+
+Goal
+====
+
+In this tutorial you will learn how to:
+
+a. Use the OpenCV function :warp_affine:`warpAffine <>` to implement simple remapping routines.
+b. Use the OpenCV function :get_rotation_matrix_2d:`getRotationMatrix2D <>` to obtain a :math:`2 \times 3` rotation matrix
+
+
+Theory
+======
+
+What is an Affine Transformation?
+----------------------------------
+
+#. It is any transformation that can be expressed in the form of a *matrix multiplication* (linear transformation) followed by a *vector addition* (translation). 
+
+#. From the above, We can use an Affine Transformation to express: 
+
+   a. Rotations (linear transformation)
+   b. Translations (vector addition)
+   c. Scale operations (linear transformation)
+
+   you can see that, in essence, an Affine Transformation represents a **relation** between two images. 
+ 
+#. The usual way to represent an Affine Transform is by using a :math:`2 \times 3` matrix. 
+
+   .. math:: 
+
+      A = \begin{bmatrix}
+          a_{00} & a_{01} \\ 
+          a_{10} & a_{11}
+          \end{bmatrix}_{2 \times 2}
+      B = \begin{bmatrix}
+          b_{00} \\ 
+          b_{10}
+          \end{bmatrix}_{2 \times 1}
+  
+      M = \begin{bmatrix}
+          A & B 
+          \end{bmatrix}
+      = 
+     \begin{bmatrix}
+          a_{00} & a_{01} & b_{00} \\ 
+          a_{10} & a_{11} & b_{10} 
+     \end{bmatrix}_{2 \times 3}
+
+   Considering that we want to transform a 2D vector :math:`X = \begin{bmatrix}x \\ y\end{bmatrix}` by using :math:`A` and :math:`B`, we can do it equivalently with:
+
+ 
+   :math:`T = A \cdot \begin{bmatrix}x \\ y\end{bmatrix} + B` or   :math:`T = M \cdot  [x, y, 1]^{T}`
+
+   .. math::
+
+      T =  \begin{bmatrix}
+          a_{00}x + a_{01}y + b_{00} \\ 
+          a_{10}x + a_{11}y + b_{10}
+          \end{bmatrix}  
+
+
+How do we get an Affine Transformation?
+---------------------------------------
+
+1. Excellent question. We mentioned that an Affine Transformation is basically a **relation** between two images. The information about this relation can come,  roughly, in two ways:
+
+   a. We know both :math:`X` and `T` and we also know that they are related. Then our job is to find :math:`M`
+
+   b. We know :math:`M` and :math:'X`. To obtain :math:`T` we only need to apply :math:`T = M \cdot X`. Our information for :math:`M` may be explicit (i.e. have the 2-by-3 matrix) or it can come as a geometric relation between points.
+
+2. Let's explain a little bit better (b). Since :math:`M` relates 02 images, we can analyze the simplest case in which it relates three points in both images. Look at the figure below:
+
+   .. image:: images/Warp_Affine_Tutorial_Theory_0.jpg
+            :alt: Theory of Warp Affine
+            :width: 350pt
+            :align: center
+
+   the points 1, 2 and 3 (forming a triangle in image 1) are mapped into image 2, still forming a triangle, but now they have changed notoriously. If we find the Affine Transformation with these 3 points (you can choose them as you like), then we can apply this found relation to the whole pixels in the image. 
+ 
+
+Code
+====
+
+#. **What does this program do?**
+ 
+   * Loads an image
+   * Applies an Affine Transform to the image. This Transform is obtained from the relation between three points. We use the function :warp_affine:`warpAffine <>` for that purpose.
+   * Applies a Rotation to the image after being transformed. This rotation is with respect to the image center
+   * Waits until the user exits the program
+ 
+#. The tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp>`_
+
+.. code-block:: cpp
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /// Global variables
+   char* source_window = "Source image";
+   char* warp_window = "Warp";
+   char* warp_rotate_window = "Warp + Rotate";
+
+   /** @function main */
+    int main( int argc, char** argv )
+    {
+      Point2f srcTri[3];
+      Point2f dstTri[3];
+
+      Mat rot_mat( 2, 3, CV_32FC1 );
+      Mat warp_mat( 2, 3, CV_32FC1 );
+      Mat src, warp_dst, warp_rotate_dst;
+
+      /// Load the image
+      src = imread( argv[1], 1 );
+
+      /// Set the dst image the same type and size as src  
+      warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
+
+      /// Set your 3 points to calculate the  Affine Transform
+      srcTri[0] = Point2f( 0,0 );
+      srcTri[1] = Point2f( src.cols - 1, 0 );
+      srcTri[2] = Point2f( 0, src.rows - 1 );
+  
+      dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );
+      dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );
+      dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );
+
+      /// Get the Affine Transform
+      warp_mat = getAffineTransform( srcTri, dstTri );
+
+      /// Apply the Affine Transform just found to the src image
+      warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
+
+      /** Rotating the image after Warp */
+
+      /// Compute a rotation matrix with respect to the center of the image
+      Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
+      double angle = -50.0;
+      double scale = 0.6;
+
+      /// Get the rotation matrix with the specifications above
+      rot_mat = getRotationMatrix2D( center, angle, scale );
+
+      /// Rotate the warped image
+      warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
+  
+      /// Show what you got
+      namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+      imshow( source_window, src );
+
+      namedWindow( warp_window, CV_WINDOW_AUTOSIZE );
+      imshow( warp_window, warp_dst );
+
+      namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );
+      imshow( warp_rotate_window, warp_rotate_dst );
+
+      /// Wait until user exits the program
+      waitKey(0);
+
+      return 0;
+     }
+
+Explanation
+===========
+
+#. Declare some variables we will use, such as the matrices to store our results and 2 arrays of points to store the 2D points that define our Affine Transform.
+
+   .. code-block:: cpp
+
+      Point2f srcTri[3];
+      Point2f dstTri[3];
+
+      Mat rot_mat( 2, 3, CV_32FC1 );
+      Mat warp_mat( 2, 3, CV_32FC1 );
+      Mat src, warp_dst, warp_rotate_dst;
+
+#. Load an image:
+
+   .. code-block:: cpp
+
+      src = imread( argv[1], 1 );
+
+#. Initialize the destination image as having the same size and type as the source:
+
+   .. code-block:: cpp
+  
+      warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
+
+#. **Affine Transform:** As we explained lines above, we need two sets of 3 points to derive the affine transform relation. Take a look:
+
+   .. code-block:: cpp
+
+      srcTri[0] = Point2f( 0,0 );
+      srcTri[1] = Point2f( src.cols - 1, 0 );
+      srcTri[2] = Point2f( 0, src.rows - 1 );
+  
+      dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );
+      dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );
+      dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );
+   
+   You may want to draw the points to make a better idea of how they change. Their locations are approximately the same as the ones depicted in the example figure (in the Theory section). You may note that the size and orientation of the triangle defined by the 3 points change.
+
+#. Armed with both sets of points, we calculate the Affine Transform by using OpenCV function :get_affine_transform:`getAffineTransform <>`:
+
+   .. code-block:: cpp
+
+      warp_mat = getAffineTransform( srcTri, dstTri );
+
+
+   We get as an output a :math:`2 \times 3` matrix (in this case **warp_mat**)
+
+#. We apply the Affine Transform just found to the src image
+
+   .. code-block:: cpp
+
+      warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
+
+   with the following arguments:
+
+   * **src**: Input image
+   * **warp_dst**: Output image
+   * **warp_mat**: Affine transform
+   * **warp_dst.size()**: The desired size of the output image
+
+   We just got our first transformed image! We will display it in one bit. Before that, we also want to rotate it...
+
+#. **Rotate:**
+   To rotate an image, we need to know two things:
+
+   a. The center with respect to which the image will rotate
+   b. The angle to be rotated. In OpenCV a positive angle is counter-clockwise
+   c. *Optional:* A scale factor
+
+   We define these parameters with the following snippet:
+
+   .. code-block:: cpp
+
+      Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
+      double angle = -50.0;
+      double scale = 0.6;
+
+#. We generate the rotation matrix with the OpenCV function :get_rotation_matrix_2d:`getRotationMatrix2D <>`, which returns a :math:`2 \times 3` matrix (in this case *rot_mat*)
+
+   .. code-block:: cpp
+
+      rot_mat = getRotationMatrix2D( center, angle, scale );
+
+#. We now apply the found rotation to the output of our previous Transformation.
+
+   .. code-block:: cpp
+
+      warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
+
+#. Finally, we display our results in two windows plus the original image for good measure:
+
+   .. code-block:: cpp
+  
+      namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+      imshow( source_window, src );
+
+      namedWindow( warp_window, CV_WINDOW_AUTOSIZE );
+      imshow( warp_window, warp_dst );
+
+      namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );
+      imshow( warp_rotate_window, warp_rotate_dst );
+
+
+#. We just have to wait until the user exits the program
+
+   .. code-block:: cpp
+
+      waitKey(0);
+
+
+
+Result
+======
+
+#. After compiling the code above, we can give it the path of an image as argument. For instance, for a picture like:
+
+   .. image:: images/Warp_Affine_Tutorial_Original_Image.jpg
+            :alt: Original image
+            :width: 250pt
+            :align: center
+   
+   after applying the first Affine Transform we obtain:
+
+   .. image:: images/Warp_Affine_Tutorial_Result_Warp.jpg
+            :alt: Original image
+            :width: 250pt
+            :align: center
+
+   and finally, after applying a negative rotation (remember negative means clockwise) and a scale factor, we get:
+
+   .. image:: images/Warp_Affine_Tutorial_Result_Warp_Rotate.jpg
+            :alt: Original image
+            :width: 250pt
+            :align: center
+
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.jpg b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..dc2d1e7486
Binary files /dev/null and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.png
deleted file mode 100644
index 5a7ba1194f..0000000000
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Original_Image.jpg
index 2f98d8359b..8aa7ff2bc0 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Original_Image.jpg and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_BlackHat.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_BlackHat.png
index ceb4e6ebc1..ce6ff35550 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_BlackHat.png and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_BlackHat.png differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Closing.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Closing.png
index faa7859fd9..f112bfef11 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Closing.png and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Closing.png differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Gradient.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Gradient.png
index 7de2bc386a..5d8077f0d2 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Gradient.png and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Gradient.png differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Opening.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Opening.png
index d40b9bba16..7b8b0850fd 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Opening.png and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_Opening.png differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_TopHat.png b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_TopHat.png
index 98d0a92e9a..ca22789b03 100644
Binary files a/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_TopHat.png and b/doc/tutorials/imgproc/opening_closing_hats/images/Morphology_2_Tutorial_Theory_TopHat.png differ
diff --git a/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.rst b/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.rst
index 896a564da8..40b06a5ea5 100644
--- a/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.rst
+++ b/doc/tutorials/imgproc/opening_closing_hats/opening_closing_hats.rst
@@ -44,7 +44,6 @@ Opening
 * For instance, check out the example below. The image at the left is the original and the image at the right is the result after applying the opening transformation. We can observe that the small spaces in the corners of the letter tend to dissapear.
 
   .. image:: images/Morphology_2_Tutorial_Theory_Opening.png
-     :height: 150pt
      :alt: Opening
      :align: center  
 
@@ -60,7 +59,6 @@ Closing
 * Useful to remove small holes (dark regions). 
 
   .. image:: images/Morphology_2_Tutorial_Theory_Closing.png
-     :height: 150pt
      :alt: Closing example
      :align: center  
 
@@ -77,7 +75,6 @@ Morphological Gradient
 * It is useful for finding the outline of an object as can be seen below:
 
   .. image:: images/Morphology_2_Tutorial_Theory_Gradient.png
-     :height: 150pt
      :alt: Gradient
      :align: center  
 
@@ -92,7 +89,6 @@ Top Hat
      dst = tophat( src, element ) = src - open( src, element )
 
   .. image:: images/Morphology_2_Tutorial_Theory_TopHat.png
-     :height: 150pt
      :alt: Top Hat
      :align: center  
 
@@ -106,7 +102,6 @@ Black Hat
      dst = blackhat( src, element ) = close( src, element ) - src
 
   .. image:: images/Morphology_2_Tutorial_Theory_BlackHat.png
-     :height: 150pt
      :alt: Black Hat
      :align: center    
 
@@ -270,17 +265,15 @@ Explanation
 Results
 ========
 
-* After compiling the code above we can execute it giving an image path as an argument. For this tutorial we use as input the image: **baboon.jpg**:
+* After compiling the code above we can execute it giving an image path as an argument. For this tutorial we use as input the image: **baboon.png**:
 
   .. image:: images/Morphology_2_Tutorial_Original_Image.jpg
-     :height: 200pt
      :alt: Morphology 2: Original image
      :align: center 
 
 * And here are two snapshots of the display window. The first picture shows the output after using the operator **Opening** with a cross kernel. The second picture (right side, shows the result of using a **Blackhat** operator with an ellipse kernel.
  
-  .. image:: images/Morphology_2_Tutorial_Cover.png
-     :height: 300pt
+  .. image:: images/Morphology_2_Tutorial_Cover.jpg
      :alt: Morphology 2: Result sample
      :align: center 
 
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Cover.png b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Cover.png
deleted file mode 100644
index 2a6058508d..0000000000
Binary files a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.jpg
new file mode 100644
index 0000000000..2a4fc40d24
Binary files /dev/null and b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.png b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.png
deleted file mode 100644
index ddf66816f5..0000000000
Binary files a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_Original_Image.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.jpg b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.jpg
new file mode 100644
index 0000000000..69382aae2d
Binary files /dev/null and b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.jpg differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.png b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.png
deleted file mode 100644
index ab34b72ace..0000000000
Binary files a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrDown_Result.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.jpg b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.jpg
new file mode 100644
index 0000000000..76a3b81f95
Binary files /dev/null and b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.jpg differ
diff --git a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.png b/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.png
deleted file mode 100644
index 17f5e18cdc..0000000000
Binary files a/doc/tutorials/imgproc/pyramids/images/Pyramids_Tutorial_PyrUp_Result.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/pyramids/pyramids.rst b/doc/tutorials/imgproc/pyramids/pyramids.rst
index 764463f8ba..41c734742f 100644
--- a/doc/tutorials/imgproc/pyramids/pyramids.rst
+++ b/doc/tutorials/imgproc/pyramids/pyramids.rst
@@ -103,7 +103,7 @@ This tutorial code's is shown lines below. You can also download it from `here <
      printf( " * [ESC] -> Close program \n \n" );
 
      /// Test image - Make sure it s divisible by 2^{n}
-     src = imread( "../images/chicky_512.png" );
+     src = imread( "../images/chicky_512.jpg" );
      if( !src.data )
        { printf(" No data! -- Exiting the program \n");
          return -1; }
@@ -148,7 +148,7 @@ Explanation
      .. code-block:: cpp
 
         /// Test image - Make sure it s divisible by 2^{n}
-        src = imread( "../images/chicky_512.png" );
+        src = imread( "../images/chicky_512.jpg" );
         if( !src.data )
           { printf(" No data! -- Exiting the program \n");
             return -1; }
@@ -235,21 +235,21 @@ Explanation
 Results
 ========
 
-* After compiling the code above we can test it. The program calls an image **chicky_512.png** that comes in the *tutorial_code/image* folder. Notice that this image is :math:`512 \times 512`, hence a downsample won't generate any error (:math:`512 = 2^{9}`). The original image is shown below:
+* After compiling the code above we can test it. The program calls an image **chicky_512.jpg** that comes in the *tutorial_code/image* folder. Notice that this image is :math:`512 \times 512`, hence a downsample won't generate any error (:math:`512 = 2^{9}`). The original image is shown below:
 
-  .. image:: images/Pyramids_Tutorial_Original_Image.png
+  .. image:: images/Pyramids_Tutorial_Original_Image.jpg
      :alt: Pyramids: Original image	
      :align: center 
 
 * First we apply two successive :pyr_down:`pyrDown <>` operations by pressing 'd'. Our output is:
  
-  .. image:: images/Pyramids_Tutorial_PyrDown_Result.png
+  .. image:: images/Pyramids_Tutorial_PyrDown_Result.jpg
      :alt: Pyramids: PyrDown Result
      :align: center 
 
 * Note that we should have lost some resolution due to the fact that we are diminishing the size of the image. This is evident after we apply :pyr_up:`pyrUp <>` twice (by pressing 'u'). Our output is now:
  
-  .. image:: images/Pyramids_Tutorial_PyrUp_Result.png
+  .. image:: images/Pyramids_Tutorial_PyrUp_Result.jpg
      :alt: Pyramids: PyrUp Result
      :align: center 
 
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.rst b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.rst
new file mode 100644
index 0000000000..1d7e1f2642
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/bounding_rects_circles.rst
@@ -0,0 +1,124 @@
+.. _bounding_rects_circles:
+
+
+Creating Bounding boxes and circles for contours
+*************************************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :bounding_rect:`boundingRect <>` 
+   * Use the OpenCV function :min_enclosing_circle:`minEnclosingCircle <>`
+          
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   Mat src; Mat src_gray;
+   int thresh = 100;
+   int max_thresh = 255;
+   RNG rng(12345);
+
+   /// Function header
+   void thresh_callback(int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+
+     /// Convert image to gray and blur it
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+     blur( src_gray, src_gray, Size(3,3) );
+
+     /// Create Window
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+
+     createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+     thresh_callback( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function thresh_callback */
+   void thresh_callback(int, void* )
+   {
+     Mat threshold_output;
+     vector<vector<Point> > contours;
+     vector<Vec4i> hierarchy;
+
+     /// Detect edges using Threshold
+     threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+     /// Find contours  
+     findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+     /// Approximate contours to polygons + get bounding rects and circles
+     vector<vector<Point> > contours_poly( contours.size() );
+     vector<Rect> boundRect( contours.size() );
+     vector<Point2f>center( contours.size() );
+     vector<float>radius( contours.size() );
+
+     for( int i = 0; i < contours.size(); i++ )
+        { approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true ); 
+          boundRect[i] = boundingRect( Mat(contours_poly[i]) ); 
+          minEnclosingCircle( contours_poly[i], center[i], radius[i] );
+        } 
+
+
+     /// Draw polygonal contour + bonding rects + circles
+     Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+     for( int i = 0; i< contours.size(); i++ )
+        { 
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          drawContours( drawing, contours_poly, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+          rectangle( drawing, boundRect[i].tl(), boundRect[i].br(), color, 2, 8, 0 );
+          circle( drawing, center[i], (int)radius[i], color, 2, 8, 0 );
+        }
+
+     /// Show in a window
+     namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+     imshow( "Contours", drawing );
+   }
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ========== ==========  
+    |BRC_0|   |BRC_1|   
+   ========== ==========   
+
+   .. |BRC_0|  image:: images/Bounding_Rects_Circles_Source_Image.jpg
+                    :align: middle
+
+   .. |BRC_1|  image:: images/Bounding_Rects_Circles_Result.jpg
+                    :align: middle   
+
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Result.jpg b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Result.jpg
new file mode 100644
index 0000000000..d13234543d
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Result.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Source_Image.jpg b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Source_Image.jpg
new file mode 100644
index 0000000000..3c08c13161
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/bounding_rects_circles/images/Bounding_Rects_Circles_Source_Image.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/bounding_rotated_ellipses.rst b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/bounding_rotated_ellipses.rst
new file mode 100644
index 0000000000..1e679ea397
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/bounding_rotated_ellipses.rst
@@ -0,0 +1,126 @@
+.. _bounding_rotated_ellipses:
+
+
+Creating Bounding rotated boxes and ellipses for contours
+**********************************************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :min_area_rect:`minAreaRect <>` 
+   * Use the OpenCV function :fit_ellipse:`fitEllipse <>`
+           
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   Mat src; Mat src_gray;
+   int thresh = 100;
+   int max_thresh = 255;
+   RNG rng(12345);
+
+   /// Function header
+   void thresh_callback(int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+
+     /// Convert image to gray and blur it
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+     blur( src_gray, src_gray, Size(3,3) );
+
+     /// Create Window
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+
+     createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+     thresh_callback( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function thresh_callback */
+   void thresh_callback(int, void* )
+   {
+     Mat threshold_output;
+     vector<vector<Point> > contours;
+     vector<Vec4i> hierarchy;
+
+     /// Detect edges using Threshold
+     threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+     /// Find contours  
+     findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+     /// Find the rotated rectangles and ellipses for each contour
+     vector<RotatedRect> minRect( contours.size() );
+     vector<RotatedRect> minEllipse( contours.size() );
+
+     for( int i = 0; i < contours.size(); i++ )
+        { minRect[i] = minAreaRect( Mat(contours[i]) ); 
+          if( contours[i].size() > 5 )
+            { minEllipse[i] = fitEllipse( Mat(contours[i]) ); }
+        } 
+
+     /// Draw contours + rotated rects + ellipses
+     Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+     for( int i = 0; i< contours.size(); i++ )
+        { 
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          // contour
+          drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+          // ellipse
+          ellipse( drawing, minEllipse[i], color, 2, 8 );
+          // rotated rectangle        
+          Point2f rect_points[4]; minRect[i].points( rect_points );
+          for( int j = 0; j < 4; j++ )
+             line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 ); 
+        }
+
+     /// Show in a window
+     namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+     imshow( "Contours", drawing ); 
+   }
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ========== ==========  
+    |BRE_0|   |BRE_1|   
+   ========== ==========   
+
+   .. |BRE_0|  image:: images/Bounding_Rotated_Ellipses_Source_Image.jpg
+                    :align: middle
+
+   .. |BRE_1|  image:: images/Bounding_Rotated_Ellipses_Result.jpg
+                    :align: middle   
+
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Result.jpg b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Result.jpg
new file mode 100644
index 0000000000..cc869fd808
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Result.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Source_Image.jpg b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Source_Image.jpg
new file mode 100644
index 0000000000..c475ebd221
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/bounding_rotated_ellipses/images/Bounding_Rotated_Ellipses_Source_Image.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/find_contours/find_contours.rst b/doc/tutorials/imgproc/shapedescriptors/find_contours/find_contours.rst
new file mode 100644
index 0000000000..fa46610d94
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/find_contours/find_contours.rst
@@ -0,0 +1,107 @@
+.. _find_contours:
+
+Finding contours in your image
+******************************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :find_contours:`findContours <>` 
+   * Use the OpenCV function :draw_contours:`drawContours <>` 
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   Mat src; Mat src_gray;
+   int thresh = 100;
+   int max_thresh = 255;
+   RNG rng(12345);
+
+   /// Function header
+   void thresh_callback(int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+
+     /// Convert image to gray and blur it
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+     blur( src_gray, src_gray, Size(3,3) );
+
+     /// Create Window
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+
+     createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
+     thresh_callback( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function thresh_callback */
+   void thresh_callback(int, void* )
+   {
+     Mat canny_output;
+     vector<vector<Point> > contours;
+     vector<Vec4i> hierarchy;
+
+     /// Detect edges using canny
+     Canny( src_gray, canny_output, thresh, thresh*2, 3 );
+     /// Find contours  
+     findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+     /// Draw contours
+     Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+     for( int i = 0; i< contours.size(); i++ )
+        { 
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+        }
+
+     /// Show in a window
+     namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+     imshow( "Contours", drawing ); 
+   }
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ============= =============  
+    |contour_0|   |contour_1|   
+   ============= =============   
+
+   .. |contour_0|  image:: images/Find_Contours_Original_Image.jpg
+                     :align: middle
+
+   .. |contour_1|  image:: images/Find_Contours_Result.jpg
+                     :align: middle   
+
diff --git a/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Original_Image.jpg b/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Original_Image.jpg
new file mode 100644
index 0000000000..0372edad81
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Result.jpg b/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Result.jpg
new file mode 100644
index 0000000000..953eeabf92
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/find_contours/images/Find_Contours_Result.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/hull/hull.rst b/doc/tutorials/imgproc/shapedescriptors/hull/hull.rst
new file mode 100644
index 0000000000..b47125a24b
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/hull/hull.rst
@@ -0,0 +1,116 @@
+.. _hull:
+
+Convex Hull
+***********
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :convex_hull:`convexHull <>` 
+
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp" 
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   Mat src; Mat src_gray;
+   int thresh = 100; 
+   int max_thresh = 255;
+   RNG rng(12345);
+
+   /// Function header
+   void thresh_callback(int, void* );
+
+  /** @function main */
+  int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+
+     /// Convert image to gray and blur it
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+     blur( src_gray, src_gray, Size(3,3) );
+
+     /// Create Window
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+
+     createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+     thresh_callback( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function thresh_callback */
+   void thresh_callback(int, void* )
+   {
+     Mat src_copy = src.clone();
+     Mat threshold_output;
+     vector<vector<Point> > contours;
+     vector<Vec4i> hierarchy;
+
+     /// Detect edges using Threshold
+     threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+
+     /// Find contours  
+     findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+     /// Find the convex hull object for each contour
+     vector<vector<Point> >hull( contours.size() );
+     for( int i = 0; i < contours.size(); i++ )
+        {  convexHull( Mat(contours[i]), hull[i], false ); } 
+
+     /// Draw contours + hull results
+     Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+     for( int i = 0; i< contours.size(); i++ )
+        { 
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+          drawContours( drawing, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point() );       
+        }
+
+     /// Show in a window
+     namedWindow( "Hull demo", CV_WINDOW_AUTOSIZE );
+     imshow( "Hull demo", drawing );
+   }
+
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ========== ==========  
+    |Hull_0|   |Hull_1|   
+   ========== ==========   
+
+   .. |Hull_0|  image:: images/Hull_Original_Image.jpg
+                     :align: middle
+
+   .. |Hull_1|  image:: images/Hull_Result.jpg
+                     :align: middle   
+
diff --git a/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Original_Image.jpg b/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Original_Image.jpg
new file mode 100644
index 0000000000..8b3f0d34a2
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Result.jpg b/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Result.jpg
new file mode 100644
index 0000000000..16ca49c01d
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/hull/images/Hull_Result.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result1.jpg b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result1.jpg
new file mode 100644
index 0000000000..1e8112a3fb
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result1.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result2.jpg b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result2.jpg
new file mode 100644
index 0000000000..d63de9a099
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Result2.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Source_Image.jpg b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Source_Image.jpg
new file mode 100644
index 0000000000..f285fdbfd3
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/moments/images/Moments_Source_Image.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/moments/moments.rst b/doc/tutorials/imgproc/shapedescriptors/moments/moments.rst
new file mode 100644
index 0000000000..8224a08e1a
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/moments/moments.rst
@@ -0,0 +1,136 @@
+.. _moments:
+
+
+Image Moments
+**************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :moments:`moments <>` 
+   * Use the OpenCV function :contour_area:`contourArea <>`
+   * Use the OpenCV function :arc_length:`arcLength <>`           
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   Mat src; Mat src_gray;
+   int thresh = 100;
+   int max_thresh = 255;
+   RNG rng(12345);
+
+   /// Function header
+   void thresh_callback(int, void* );
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Load source image and convert it to gray
+     src = imread( argv[1], 1 );
+
+     /// Convert image to gray and blur it
+     cvtColor( src, src_gray, CV_BGR2GRAY );
+     blur( src_gray, src_gray, Size(3,3) );
+
+     /// Create Window
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+
+     createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
+     thresh_callback( 0, 0 );
+
+     waitKey(0);
+     return(0);
+   }
+
+   /** @function thresh_callback */
+   void thresh_callback(int, void* )
+   {
+     Mat canny_output;
+     vector<vector<Point> > contours;
+     vector<Vec4i> hierarchy;
+
+     /// Detect edges using canny
+     Canny( src_gray, canny_output, thresh, thresh*2, 3 );
+     /// Find contours  
+     findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+     /// Get the moments
+     vector<Moments> mu(contours.size() );
+     for( int i = 0; i < contours.size(); i++ )
+        { mu[i] = moments( contours[i], false ); }
+
+     ///  Get the mass centers: 
+     vector<Point2f> mc( contours.size() );
+     for( int i = 0; i < contours.size(); i++ )
+        { mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }
+
+     /// Draw contours
+     Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+     for( int i = 0; i< contours.size(); i++ )
+        { 
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+          circle( drawing, mc[i], 4, color, -1, 8, 0 );
+        }
+
+     /// Show in a window
+     namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+     imshow( "Contours", drawing );
+
+     /// Calculate the area with the moments 00 and compare with the result of the OpenCV function
+     printf("\t Info: Area and Contour Length \n");
+     for( int i = 0; i< contours.size(); i++ )
+        {
+          printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );  
+          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+          drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+          circle( drawing, mc[i], 4, color, -1, 8, 0 );
+        }
+   }
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ========== ==========  ==========  
+    |MU_0|     |MU_1|      |MU_2|   
+   ========== ==========  ========== 
+
+   .. |MU_0|  image:: images/Moments_Source_Image.jpg
+                    :width: 250pt
+                    :align: middle
+
+   .. |MU_1|  image:: images/Moments_Result1.jpg
+                    :width: 250pt
+                    :align: middle   
+
+   .. |MU_2|  image:: images/Moments_Result2.jpg
+                    :width: 250pt
+                    :align: middle   
+
diff --git a/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Result.jpg b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Result.jpg
new file mode 100644
index 0000000000..e420f472ea
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Result.jpg differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Source_Image.png b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Source_Image.png
new file mode 100644
index 0000000000..87bf5d2100
Binary files /dev/null and b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/images/Point_Polygon_Test_Source_Image.png differ
diff --git a/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/point_polygon_test.rst b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/point_polygon_test.rst
new file mode 100644
index 0000000000..f3fa84c542
--- /dev/null
+++ b/doc/tutorials/imgproc/shapedescriptors/point_polygon_test/point_polygon_test.rst
@@ -0,0 +1,117 @@
+.. _point_polygon_test:
+
+Point Polygon Test
+*******************
+
+Goal
+=====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * Use the OpenCV function :point_polygon_test:`pointPolygonTest <>` 
+           
+
+Theory
+======
+
+Code
+====
+
+This tutorial code's is shown lines below. You can also download it from `here <https://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp>`_
+
+.. code-block:: cpp 
+
+   #include "opencv2/highgui/highgui.hpp"
+   #include "opencv2/imgproc/imgproc.hpp"
+   #include <iostream>
+   #include <stdio.h>
+   #include <stdlib.h>
+
+   using namespace cv;
+   using namespace std;
+
+   /** @function main */
+   int main( int argc, char** argv )
+   {
+     /// Create an image
+     const int r = 100;
+     Mat src = Mat::zeros( Size( 4*r, 4*r ), CV_8UC1 );
+
+     /// Create a sequence of points to make a contour:
+     vector<Point2f> vert(6);
+
+     vert[0] = Point( 1.5*r, 1.34*r );
+     vert[1] = Point( 1*r, 2*r );
+     vert[2] = Point( 1.5*r, 2.866*r );
+     vert[3] = Point( 2.5*r, 2.866*r );
+     vert[4] = Point( 3*r, 2*r );
+     vert[5] = Point( 2.5*r, 1.34*r );
+
+     /// Draw it in src
+     for( int j = 0; j < 6; j++ )
+        { line( src, vert[j],  vert[(j+1)%6], Scalar( 255 ), 3, 8 ); } 
+
+     /// Get the contours
+     vector<vector<Point> > contours; vector<Vec4i> hierarchy;
+     Mat src_copy = src.clone();
+
+     findContours( src_copy, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);  
+
+     /// Calculate the distances to the contour
+     Mat raw_dist( src.size(), CV_32FC1 );
+
+     for( int j = 0; j < src.rows; j++ )
+        { for( int i = 0; i < src.cols; i++ )
+             { raw_dist.at<float>(j,i) = pointPolygonTest( contours[0], Point2f(i,j), true ); }
+        }
+
+     double minVal; double maxVal;
+     minMaxLoc( raw_dist, &minVal, &maxVal, 0, 0, Mat() );
+     minVal = abs(minVal); maxVal = abs(maxVal);
+  
+     /// Depicting the  distances graphically
+     Mat drawing = Mat::zeros( src.size(), CV_8UC3 );
+
+     for( int j = 0; j < src.rows; j++ )
+        { for( int i = 0; i < src.cols; i++ )
+             { 
+               if( raw_dist.at<float>(j,i) < 0 )
+                 { drawing.at<Vec3b>(j,i)[0] = 255 - (int) abs(raw_dist.at<float>(j,i))*255/minVal; }
+               else if( raw_dist.at<float>(j,i) > 0 )
+                 { drawing.at<Vec3b>(j,i)[2] = 255 - (int) raw_dist.at<float>(j,i)*255/maxVal; }    
+               else
+                 { drawing.at<Vec3b>(j,i)[0] = 255; drawing.at<Vec3b>(j,i)[1] = 255; drawing.at<Vec3b>(j,i)[2] = 255; }     
+             }
+        }
+
+     /// Create Window and show your results
+     char* source_window = "Source";
+     namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+     imshow( source_window, src );
+     namedWindow( "Distance", CV_WINDOW_AUTOSIZE );
+     imshow( "Distance", drawing );
+
+     waitKey(0);
+     return(0);
+   }
+
+Explanation
+============
+
+Result
+======
+
+#. Here it is:
+
+   ========== ==========  
+    |PPT_0|   |PPT_1|   
+   ========== ==========   
+
+   .. |PPT_0|  image:: images/Point_Polygon_Test_Source_Image.png
+                    :align: middle
+
+   .. |PPT_1|  image:: images/Point_Polygon_Test_Result.jpg
+                    :align: middle   
+
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..67da3a5ac0
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.png b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.png
deleted file mode 100644
index 2f9b038058..0000000000
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_1_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..b3a1c55659
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.png b/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.png
deleted file mode 100644
index 6e6aed9aa2..0000000000
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/Morphology_2_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..0851cab278
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.png b/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.png
deleted file mode 100644
index 2fbee16bef..0000000000
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/Pyramids_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..67656ab4b3
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.png b/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.png
deleted file mode 100644
index f05676b4bf..0000000000
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/Smoothing_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..6b115d88f5
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.png b/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.png
deleted file mode 100644
index 015e8c330b..0000000000
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/Threshold_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Back_Projection_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Back_Projection_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..013bdf6f2f
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Back_Projection_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Calculation_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Calculation_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..32d09e37e8
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Calculation_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Comparison_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Comparison_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..7538a7203d
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Comparison_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Equalization_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Equalization_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..fbc5866835
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Histogram_Equalization_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Template_Matching_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Template_Matching_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..e84f52119a
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/histograms/Template_Matching_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Canny_Detector_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Canny_Detector_Tutorial_Cover.jpg
index bbddc716f6..bcd9ff9ace 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Canny_Detector_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Canny_Detector_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/CopyMakeBorder_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/CopyMakeBorder_Tutorial_Cover.jpg
index 5e91f407fa..f241ff2238 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/CopyMakeBorder_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/CopyMakeBorder_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Filter_2D_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Filter_2D_Tutorial_Cover.jpg
index eb02934d38..c2f5809108 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Filter_2D_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Filter_2D_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Circle_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Circle_Tutorial_Cover.jpg
index 2a599fc6ca..175180ae81 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Circle_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Circle_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Lines_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Lines_Tutorial_Cover.jpg
index a6107b02b5..4211ee2629 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Lines_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Hough_Lines_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Laplace_Operator_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Laplace_Operator_Tutorial_Cover.jpg
index 2354d9a5db..14373f25b1 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Laplace_Operator_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Laplace_Operator_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Remap_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Remap_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..bfb55dbdac
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Remap_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Sobel_Derivatives_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Sobel_Derivatives_Tutorial_Cover.jpg
index ead594e5eb..fbe17c8978 100644
Binary files a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Sobel_Derivatives_Tutorial_Cover.jpg and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Sobel_Derivatives_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Warp_Affine_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Warp_Affine_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..5655789bd6
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/imgtrans/Warp_Affine_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rects_Circles_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rects_Circles_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..be2ae57d40
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rects_Circles_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rotated_Ellipses_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rotated_Ellipses_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..b7330592b5
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Bounding_Rotated_Ellipses_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Find_Contours_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Find_Contours_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..82888a1ba9
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Find_Contours_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Hull_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Hull_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..a7a1b6ebeb
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Hull_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Moments_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Moments_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..1e865eb371
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Moments_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Point_Polygon_Test_Tutorial_Cover.jpg b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Point_Polygon_Test_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..9980df8421
Binary files /dev/null and b/doc/tutorials/imgproc/table_of_content_imgproc/images/shapedescriptors/Point_Polygon_Test_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/table_of_content_imgproc/table_of_content_imgproc.rst b/doc/tutorials/imgproc/table_of_content_imgproc/table_of_content_imgproc.rst
index ded5264c02..80ee5b7055 100644
--- a/doc/tutorials/imgproc/table_of_content_imgproc/table_of_content_imgproc.rst
+++ b/doc/tutorials/imgproc/table_of_content_imgproc/table_of_content_imgproc.rst
@@ -5,57 +5,54 @@
 
 In this section you will learn about the image processing (manipulation) functions inside OpenCV.
 
-.. toctree::
-   :hidden:
-   
-   ../gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter
-   ../erosion_dilatation/erosion_dilatation
-   ../opening_closing_hats/opening_closing_hats
-   ../pyramids/pyramids
-   ../threshold/threshold
+.. include:: ../../definitions/tocDefinitions.rst
 
-.. |Author_AnaH| unicode:: Ana U+0020 Huam U+00E1 n
-
-* :ref:`Smoothing`
+ 
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
 
   ===================== ==============================================
-   |ImageProcessing_1|  *Title:* **Smoothing Images**
-
+   |ImageProcessing_1|  **Title:** :ref:`Smoothing`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
                         
                         Let's take a look at some basic linear filters!
- 
+  
   ===================== ==============================================
- 
-  .. |ImageProcessing_1| image:: images/Smoothing_Tutorial_Cover.png
-                         :height: 100pt
-                         :width:  100pt
-
-
-* :ref:`Morphology_1`
+  
+  .. |ImageProcessing_1| image:: images/Smoothing_Tutorial_Cover.jpg
+                         :height: 90pt
+                         :width:  90pt
+  
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
 
   ===================== ==============================================
-   |ImageProcessing_2|  *Title:* **Erosion and Dilation**
-
+   |ImageProcessing_2|  **Title:** :ref:`Morphology_1`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         Author: |Author_AnaH|
-
+  
                         Let's *change* the shape of objects!
- 
+  
   ===================== ==============================================
- 
-  .. |ImageProcessing_2| image:: images/Morphology_1_Tutorial_Cover.png
-                         :height: 100pt
-                         :width:  100pt
-
-* :ref:`Morphology_2`
+  
+  .. |ImageProcessing_2| image:: images/Morphology_1_Tutorial_Cover.jpg
+                         :height: 90pt
+                         :width:  90pt
+     
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
 
   ================= ==================================================
-   |Morphology_2|   *Title:* **More advanced Morphology Transformations**
-
+   |Morphology_2|   **Title:** :ref:`Morphology_2`
+  
                     *Compatibility:* > OpenCV 2.0
                     
                     *Author:* |Author_AnaH|
@@ -64,171 +61,484 @@ In this section you will learn about the image processing (manipulation) functio
   
   ================= ==================================================
   
-  .. |Morphology_2| image:: images/Morphology_2_Tutorial_Cover.png
-                     :height: 100pt
-                     :width:  100pt
-
-
-* :ref:`Pyramids`
+  .. |Morphology_2| image:: images/Morphology_2_Tutorial_Cover.jpg
+                     :height: 90pt
+                     :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |Pyramids|           *Title:* **Image Pyramids**
-
+   |Pyramids|           **Title:** :ref:`Pyramids`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         What if I need a bigger/smaller image?
- 
-  ===================== ==============================================
- 
-  .. |Pyramids| image:: images/Pyramids_Tutorial_Cover.png
-                      :height: 100pt
-                      :width:  100pt
-
-
-* :ref:`Basic_Threshold`
-
-  ===================== ==============================================
-   |Threshold|          *Title:* **Basic Thresholding Operations**
-
-                        *Compatibility:* > OpenCV 2.0
-                        
-                        *Author:* |Author_AnaH|
-
-                        After so much processing, it is time to decide which pixels stay!
-
+  
   ===================== ==============================================
   
-  .. |Threshold| image:: images/Threshold_Tutorial_Cover.png
-                      :height: 100pt
-                      :width:  100pt
-
-.. ************************
-.. ImgTrans
-.. ************************
-
-* :ref:`filter_2d`
+  .. |Pyramids| image:: images/Pyramids_Tutorial_Cover.jpg
+                      :height: 90pt
+                      :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |Filter_2D|          *Title:* **Making your own linear filters**
-
+   |Threshold|          **Title:** :ref:`Basic_Threshold`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
+                        After so much processing, it is time to decide which pixels stay!
+  
+  ===================== ==============================================
+  
+  .. |Threshold| image:: images/Threshold_Tutorial_Cover.jpg
+                      :height: 90pt
+                      :width:  90pt
+  
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+    
++ 
+  ===================== ==============================================
+   |Filter_2D|          **Title:** :ref:`filter_2d`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+  
                         Where we learn to design our own filters by using OpenCV functions
-
+  
   ===================== ==============================================
   
   .. |Filter_2D| image:: images/imgtrans/Filter_2D_Tutorial_Cover.jpg
-                      :height: 100pt
-                      :width:  100pt
-
-
-* :ref:`copyMakeBorder`
-
+                      :height: 90pt
+                      :width:  90pt
+  
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+    
++ 
   ===================== ==============================================
-   |CopyMakeBorder|     *Title:* **Adding borders to your images**
-
+   |CopyMakeBorder|     **Title:** :ref:`copyMakeBorderTutorial`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         Where we learn how to pad our images!
-
+  
   ===================== ==============================================
   
   .. |CopyMakeBorder| image:: images/imgtrans/CopyMakeBorder_Tutorial_Cover.jpg
-                           :height: 100pt
-                           :width:  100pt
-
-
-* :ref:`sobel_derivatives`
+                           :height: 90pt
+                           :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |SobelDerivatives|   *Title:* **Sobel Derivatives**
-
+   |SobelDerivatives|   **Title:** :ref:`sobel_derivatives`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         Where we learn how to calculate gradients and use them to detect edges!
-
+  
   ===================== ==============================================
   
   .. |SobelDerivatives| image:: images/imgtrans/Sobel_Derivatives_Tutorial_Cover.jpg
-                             :height: 100pt
-                             :width:  100pt
-
-* :ref:`laplace_operator`
+                             :height: 90pt
+                             :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |LaplaceOperator|    *Title:* **Laplace Operator**
-
+   |LaplaceOperator|    **Title:** :ref:`laplace_operator`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         Where we learn about the *Laplace* operator and how to detect edges with it.
-
+  
   ===================== ==============================================
   
   .. |LaplaceOperator| image:: images/imgtrans/Laplace_Operator_Tutorial_Cover.jpg
-                             :height: 100pt
-                             :width:  100pt
-
-
-* :ref:`canny_detector`
+                             :height: 90pt
+                             :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |CannyDetector|      *Title:* **Canny Edge Detector**
-
+   |CannyDetector|      **Title:** :ref:`canny_detector`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         Where we learn a sophisticated alternative to detect edges.
-
+  
   ===================== ==============================================
   
   .. |CannyDetector| image:: images/imgtrans/Canny_Detector_Tutorial_Cover.jpg
-                           :height: 100pt
-                           :width:  100pt
-
-
-* :ref:`hough_lines`
+                           :height: 90pt
+                           :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |HoughLines|         *Title:* **Hough Line Transform**
-
+   |HoughLines|         **Title:** :ref:`hough_lines`
+  
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
-
+  
                         Where we learn how to detect lines
-
+  
   ===================== ==============================================
   
   .. |HoughLines| image:: images/imgtrans/Hough_Lines_Tutorial_Cover.jpg
-                        :height: 100pt
-                        :width:  100pt
-
-
-* :ref:`hough_circle`
+                        :height: 90pt
+                        :width:  90pt
+  
++ 
 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
   ===================== ==============================================
-   |HoughCircle|        *Title:* **Hough Circle Transform**
+   |HoughCircle|        **Title:** :ref:`hough_circle`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+  
+                        Where we learn how to detect circles
+  
+  ===================== ==============================================
+  
+  .. |HoughCircle| image:: images/imgtrans/Hough_Circle_Tutorial_Cover.jpg
+                         :height: 90pt
+                         :width:  90pt
+  
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |Remap|              **Title:** :ref:`remap`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+  
+                        Where we learn how to manipulate pixels locations
+  
+  ===================== ==============================================
+  
+  .. |Remap| image:: images/imgtrans/Remap_Tutorial_Cover.jpg
+                   :height: 90pt
+                   :width:  90pt
+  
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |WarpAffine|         **Title:** :ref:`warp_affine`
+  
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+  
+                        Where we learn how to rotate, translate and scale our images
+  
+  ===================== ==============================================
+  
+  .. |WarpAffine| image:: images/imgtrans/Warp_Affine_Tutorial_Cover.jpg
+                        :height: 90pt
+                        :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |HistEqualization|   **Title:** :ref:`histogram_equalization`
 
                         *Compatibility:* > OpenCV 2.0
                         
                         *Author:* |Author_AnaH|
 
-                        Where we learn how to detect circles
+                        Where we learn how to improve the contrast in our images
 
   ===================== ==============================================
   
-  .. |HoughCircle| image:: images/imgtrans/Hough_Circle_Tutorial_Cover.jpg
-                         :height: 100pt
-                         :width:  100pt
+  .. |HistEqualization| image:: images/histograms/Histogram_Equalization_Tutorial_Cover.jpg
+                              :height: 90pt
+                              :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |HistCalculation|    **Title:** :ref:`histogram_calculation`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to create and generate histograms
+
+  ===================== ==============================================
+  
+  .. |HistCalculation| image:: images/histograms/Histogram_Calculation_Tutorial_Cover.jpg
+                             :height: 90pt
+                             :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |HistComparison|     **Title:** :ref:`histogram_comparison`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn to calculate metrics between histograms
+
+  ===================== ==============================================
+  
+  .. |HistComparison| image:: images/histograms/Histogram_Comparison_Tutorial_Cover.jpg
+                            :height: 90pt
+                            :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |BackProjection|     **Title:** :ref:`back_projection`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to use histograms to find similar objects in images
+
+  ===================== ==============================================
+  
+  .. |BackProjection| image:: images/histograms/Back_Projection_Tutorial_Cover.jpg
+                            :height: 90pt
+                            :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |TemplateMatching|   **Title:** :ref:`template_matching`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to match templates in an image
+
+  ===================== ==============================================
+  
+  .. |TemplateMatching| image:: images/histograms/Template_Matching_Tutorial_Cover.jpg
+                              :height: 90pt
+                              :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |FindContours|       **Title:** :ref:`find_contours`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to find contours of objects in our image
+
+  ===================== ==============================================
+  
+  .. |FindContours| image:: images/shapedescriptors/Find_Contours_Tutorial_Cover.jpg
+                          :height: 90pt
+                          :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |Hull|               **Title:** :ref:`hull`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to get hull contours and draw them!
+
+  ===================== ==============================================
+  
+  .. |Hull| image:: images/shapedescriptors/Hull_Tutorial_Cover.jpg
+                 :height: 90pt
+                 :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  ===================== ==============================================
+   |BRC|                **Title:** :ref:`bounding_rects_circles`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to obtain bounding boxes and circles for our contours.
+
+  ===================== ==============================================
+  
+  .. |BRC| image:: images/shapedescriptors/Bounding_Rects_Circles_Tutorial_Cover.jpg
+                :height: 90pt
+                :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  
+  ===================== ==============================================
+   |BRE|                **Title:** :ref:`bounding_rotated_ellipses`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to obtain rotated bounding boxes and ellipses for our contours.
+
+  ===================== ==============================================
+  
+  .. |BRE| image:: images/shapedescriptors/Bounding_Rotated_Ellipses_Tutorial_Cover.jpg
+                :height: 90pt
+                :width:  90pt
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  
+  ===================== ==============================================
+   |MU|                 **Title:** :ref:`moments`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn to calculate the moments of an image
+
+  ===================== ==============================================
+  
+  .. |MU| image:: images/shapedescriptors/Moments_Tutorial_Cover.jpg
+               :height: 90pt
+               :width:  90pt
+
+
++ 
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  
+  ===================== ==============================================
+   |PPT|                **Title:** :ref:`point_polygon_test`
+
+                        *Compatibility:* > OpenCV 2.0
+                        
+                        *Author:* |Author_AnaH|
+
+                        Where we learn how to calculate distances from the image to contours
+
+  ===================== ==============================================
+  
+  .. |PPT| image:: images/shapedescriptors/Point_Polygon_Test_Tutorial_Cover.jpg
+                :height: 90pt
+                :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
+.. toctree::
+   :hidden:
+
+   ../gausian_median_blur_bilateral_filter/gausian_median_blur_bilateral_filter
+   ../erosion_dilatation/erosion_dilatation
+   ../opening_closing_hats/opening_closing_hats
+   ../pyramids/pyramids
+   ../threshold/threshold
+   ../imgtrans/filter_2d/filter_2d
+   ../imgtrans/copyMakeBorder/copyMakeBorder
+   ../imgtrans/sobel_derivatives/sobel_derivatives
+   ../imgtrans/laplace_operator/laplace_operator
+   ../imgtrans/canny_detector/canny_detector
+   ../imgtrans/hough_lines/hough_lines
+   ../imgtrans/hough_circle/hough_circle
+   ../imgtrans/remap/remap
+   ../imgtrans/warp_affine/warp_affine
+   ../histograms/histogram_equalization/histogram_equalization
+   ../histograms/histogram_calculation/histogram_calculation
+   ../histograms/histogram_comparison/histogram_comparison
+   ../histograms/back_projection/back_projection
+   ../histograms/template_matching/template_matching
+   ../shapedescriptors/find_contours/find_contours
+   ../shapedescriptors/hull/hull
+   ../shapedescriptors/bounding_rects_circles/bounding_rects_circles
+   ../shapedescriptors/bounding_rotated_ellipses/bounding_rotated_ellipses
+   ../shapedescriptors/moments/moments
+   ../shapedescriptors/point_polygon_test/point_polygon_test
+
+
 
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.jpg b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.jpg
new file mode 100644
index 0000000000..82a12d28e4
Binary files /dev/null and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.jpg differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.png
deleted file mode 100644
index e0161bd119..0000000000
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Cover.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.jpg b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.jpg
new file mode 100644
index 0000000000..7aaa61dc6d
Binary files /dev/null and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.jpg differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.png
deleted file mode 100644
index ddf66816f5..0000000000
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Original_Image.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.jpg b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.jpg
new file mode 100644
index 0000000000..7f6ee08aaf
Binary files /dev/null and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.jpg differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.png
deleted file mode 100644
index 72e36fa405..0000000000
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Binary_Inverted.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.jpg b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.jpg
new file mode 100644
index 0000000000..ea3039bfee
Binary files /dev/null and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.jpg differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.png
deleted file mode 100644
index ce1bfeb7f1..0000000000
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Result_Zero.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Binary_Inverted.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Binary_Inverted.png
index cfd7cc395d..1962a8c1c7 100644
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Binary_Inverted.png and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Binary_Inverted.png differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.jpg b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.jpg
new file mode 100644
index 0000000000..73112e110b
Binary files /dev/null and b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.jpg differ
diff --git a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.png b/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.png
deleted file mode 100644
index e834992341..0000000000
Binary files a/doc/tutorials/imgproc/threshold/images/Threshold_Tutorial_Theory_Example.png and /dev/null differ
diff --git a/doc/tutorials/imgproc/threshold/threshold.rst b/doc/tutorials/imgproc/threshold/threshold.rst
index 1db97811a5..1ac4919bd0 100644
--- a/doc/tutorials/imgproc/threshold/threshold.rst
+++ b/doc/tutorials/imgproc/threshold/threshold.rst
@@ -28,9 +28,8 @@ What is Thresholding?
 
 * Once we have separated properly the important pixels, we can set them with a determined value to identify them (i.e. we can assign them a value of :math:`0` (black), :math:`255` (white) or any value  that suits your needs).
 
-  .. image:: images/Threshold_Tutorial_Theory_Example.png
+  .. image:: images/Threshold_Tutorial_Theory_Example.jpg
      :alt: Threshold simple example
-     :height: 150pt
      :align: center 
 
 Types of Thresholding
@@ -44,7 +43,6 @@ Types of Thresholding
 
   .. image:: images/Threshold_Tutorial_Theory_Base_Figure.png
      :alt: Threshold Binary
-     :height: 100pt
      :align: center 
 
 Threshold Binary
@@ -60,7 +58,6 @@ Threshold Binary
 
   .. image:: images/Threshold_Tutorial_Theory_Binary.png
      :alt: Threshold Binary
-     :height: 100pt
      :align: center 
 
 
@@ -77,7 +74,6 @@ Threshold Binary, Inverted
         
   .. image:: images/Threshold_Tutorial_Theory_Binary_Inverted.png
      :alt: Threshold Binary Inverted
-     :height: 100pt
      :align: center 
 
 Truncate
@@ -93,7 +89,6 @@ Truncate
  
   .. image:: images/Threshold_Tutorial_Theory_Truncate.png
      :alt: Threshold Truncate
-     :height: 100pt
      :align: center 
         
 
@@ -111,7 +106,6 @@ Threshold to Zero
 
   .. image:: images/Threshold_Tutorial_Theory_Zero.png
      :alt: Threshold Zero
-     :height: 100pt
      :align: center 
 
 
@@ -128,7 +122,6 @@ Threshold to Zero, Inverted
 
   .. image:: images/Threshold_Tutorial_Theory_Zero_Inverted.png
      :alt: Threshold Zero Inverted
-     :height: 100pt
      :align: center 
 
 
@@ -296,25 +289,20 @@ Results
 #. After compiling this program, run it giving a path to an image as argument. For instance, for an input image as:
 
 
-   .. image:: images/Threshold_Tutorial_Original_Image.png
+   .. image:: images/Threshold_Tutorial_Original_Image.jpg
       :alt: Threshold Original Image
-      :height: 200pt
       :align: center 
 
 #. First, we try to threshold our image with a *binary threhold inverted*. We expect that the pixels brighter than the :math:`thresh` will turn dark, which is what actually happens, as we can see in the snapshot below (notice from the original image, that the doggie's tongue and eyes are particularly bright in comparison with the image, this is reflected in the output image).
 
 
-   .. image:: images/Threshold_Tutorial_Result_Binary_Inverted.png
+   .. image:: images/Threshold_Tutorial_Result_Binary_Inverted.jpg
       :alt: Threshold Result Binary Inverted
-      :height: 200pt
       :align: center 
 
 
 #. Now we try with the *threshold to zero*. With this, we expect that the darkest pixels (below the threshold) will become completely black, whereas the pixels with value greater than the threshold will keep its original value. This is verified by the following snapshot of the output image:
 
-   .. image:: images/Threshold_Tutorial_Result_Zero.png
+   .. image:: images/Threshold_Tutorial_Result_Zero.jpg
       :alt: Threshold Result Zero
-      :height: 200pt
-      :align: center 
-
- 
+      :align: center 
\ No newline at end of file
diff --git a/doc/tutorials/introduction/android_binary_package/android_binary_package.rst b/doc/tutorials/introduction/android_binary_package/android_binary_package.rst
new file mode 100644
index 0000000000..e711cb8858
--- /dev/null
+++ b/doc/tutorials/introduction/android_binary_package/android_binary_package.rst
@@ -0,0 +1,319 @@
+
+.. _Android_Binary_Package:
+
+
+Using Android binary package with Eclipse
+*****************************************
+
+This tutorial was tested using Ubuntu 10.04 and Windows 7 SP1 operating systems. Nevertheless, it should also work on any other **OS**\ es supported by Android SDK (including Mac OS X). If you encounter errors after following the steps described here, feel free to contact us via *android-opencv* discussion group https://groups.google.com/group/android-opencv/ and we will try to help you.
+
+Quick environment setup for Android development
+===============================================
+
+If you are making a clean environment installation then you can try **T**\ egra **A**\ ndroid **D**\ evelopment **P**\ ack (*TADP*) released by *NVIDIA*:
+
+  http://developer.nvidia.com/tegra-android-development-pack
+
+It will cover all of the environment set up automatically and you can go to the next step :ref:`Get_the_OpenCV_package_for_Android_development` right after automatic setup.
+
+If you are a beginner in Android development then we recommentd you to start with TADP.
+
+.. note:: *NVIDIA*\ 's Tegra Android Development Pack includes some special features for |Nvidia_Tegra_Platform|_ but it is not just for *Tegra* devices
+  
+   + You need at least *1.6 Gb* free disk space for installation.
+
+   + TADP will download Android SDK platforms and Android NDK from Google's server, so you need an Internet connection for the installation.
+
+   + TADP can ask you to flash your development kit at the end of installation process. Just skip this step if you have no |Tegra_Ventana_Development_Kit|_\ .
+
+   + (``UNIX``) TADP will ask you for a *root* in the middle of installation, so you need to be a member of *sudo* group.
+
+     ..
+
+
+.. |Nvidia_Tegra_Platform| replace:: *NVIDIA*\ ’s Tegra platform
+.. _Nvidia_Tegra_Platform: http://developer.nvidia.com/node/19071
+.. |Tegra_Ventana_Development_Kit| replace:: Tegra Ventana Development Kit
+.. _Tegra_Ventana_Development_Kit: http://developer.nvidia.com/tegra-ventana-development-kit
+
+.. _Android_Environment_Setup_Lite: 
+
+Manual environment setup for Android Development
+================================================
+
+You need the following tools to be installed:
+
+#. **Sun JDK 6**
+
+   Visit http://www.oracle.com/technetwork/java/javase/downloads/index.html and download installer for your OS.
+
+   Here is a detailed :abbr:`JDK (Java Development Kit)` installation guide for Ubuntu and Mac OS: http://source.android.com/source/initializing.html#installing-the-jdk (only JDK sections are applicable for OpenCV)
+
+   .. note:: OpenJDK is not usable for Android development because Android SDK supports only Sun JDK.
+        If you use Ubuntu, after installation of Sun JDK you should run the following command to set Sun java environment:
+
+        .. code-block:: bash
+
+           sudo update-java-alternatives --set java-6-sun
+
+#. **Android SDK**
+
+   Get the latest Android SDK from http://developer.android.com/sdk/index.html
+
+   Here is Google's install guide for SDK http://developer.android.com/sdk/installing.html
+
+   .. note:: If you choose SDK packed into Windows installer, then you should have 32-bit JRE installed. It is not needed for Android development, but installer is x86 application and requires 32-bit Java runtime.
+
+   .. note:: If you are running x64 version of Ubuntu Linux, then you need ia32 shared libraries for use on amd64 and ia64 systems to be installed. You can install them with the following command:
+
+      .. code-block:: bash
+
+         sudo apt-get install ia32-libs
+
+      For Red Hat based systems the following command might be helpful:
+
+      .. code-block:: bash
+
+         sudo yum install libXtst.i386 
+
+#. **Android SDK components**
+
+   You need the following SDK components to be installed:
+
+   * *Android SDK Tools, revision12* or newer
+
+     Older revisions should also work, but they are not recommended.
+
+   * *SDK Platform Android 2.2, API 8, revision 2* (also known as  *android-8*)
+
+     This is minimal platform supported by OpenCV Java API. And it is set as default for OpenCV distribution. It is possible to use newer platform with OpenCV package, but it requires to edit OpenCV project settings.
+
+     .. image:: images/android_sdk_and_avd_manager.png
+        :height: 400px 
+        :alt: Android SDK and AVD manager
+        :align: center
+     
+     See `Adding SDK Components
+     <http://developer.android.com/sdk/adding-components.html>`_ for help with installing/updating SDK components.
+
+#. **Eclipse IDE**
+
+   Check the `Android SDK System Requirements
+   <http://developer.android.com/sdk/requirements.html>`_ document for a list of Eclipse versions that are compatible with the Android SDK. 
+   For OpenCV 2.3.1 we recommend Eclipse 3.7 (Indigo) or Eclipse 3.6 (Helios). They work well for OpenCV under both Windows and Linux.
+   
+   If you have no Eclipse installed, you can download it from this location:
+    
+      http://www.eclipse.org/downloads/ 
+      
+#. **ADT plugin for Eclipse**
+
+   This instruction is copied from http://developer.android.com/sdk/eclipse-adt.html#downloading
+   . Please, visit that page if you have any troubles with ADT plugin installation.
+
+   Assuming that you have Eclipse IDE installed, as described above, follow these steps to download and install the ADT plugin:
+
+   #. Start Eclipse, then select :menuselection:`Help --> Install New Software...`
+   #. Click :guilabel:`Add` (in the top-right corner).
+   #. In the :guilabel:`Add Repository` dialog that appears, enter "ADT Plugin" for the Name and the following URL for the Location:
+
+      https://dl-ssl.google.com/android/eclipse/
+
+   #. Click :guilabel:`OK`
+
+      .. note:: If you have trouble acquiring the plugin, try using "http" in the Location URL, instead of "https" (https is preferred for security reasons).
+   
+   #. In the :guilabel:`Available Software` dialog, select the checkbox next to :guilabel:`Developer Tools` and click :guilabel:`Next`.
+   #. In the next window, you'll see a list of the tools to be downloaded. Click :guilabel:`Next`.
+   #. Read and accept the license agreements, then click :guilabel:`Finish`.
+
+      .. note:: If you get a security warning saying that the authenticity or validity of the software can't be established, click :guilabel:`OK`.
+   
+   #. When the installation completes, restart Eclipse. 
+
+.. _Get_the_OpenCV_package_for_Android_development:
+
+Get the OpenCV package for Android development
+==============================================
+
+#. Go to the http://sourceforge.net/projects/opencvlibrary/files/opencv-android/ and download the latest available version. Currently it is |opencv_android_bin_pack_url|_
+
+#. Create new folder for Android+OpenCV development.
+
+      .. note:: Better to use a path without spaces in it. Otherwise you will probably have problems with :command:`ndk-build`.
+
+#. Unpack the OpenCV package into that dir.
+
+   You can unpack it using any popular archiver (for example with |seven_zip|_):
+
+   .. image:: images/android_package_7zip.png
+      :alt: Exploring OpenCV package with 7-Zip
+      :align: center
+
+   On Unix you can also use the following command:
+   
+   .. code-block:: bash
+
+      tar -jxvf ~/Downloads/OpenCV-2.3.1-android-bin.tar.bz2
+      
+   For this tutorial I have unpacked OpenCV to the :file:`C:\\Work\\android-opencv\\` directory.
+
+.. |opencv_android_bin_pack| replace:: OpenCV-2.3.1-android-bin.tar.bz2
+.. _opencv_android_bin_pack_url: http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.3.1/OpenCV-2.3.1-android-bin.tar.bz2/download
+.. |opencv_android_bin_pack_url| replace:: |opencv_android_bin_pack|
+.. |seven_zip| replace:: 7-Zip
+.. _seven_zip: http://www.7-zip.org/
+
+Open OpenCV library and samples in Eclipse
+==========================================
+
+#. Start the *Eclipse* and choose your workspace location.
+
+   I recommend to start familiarizing yourself with OpenCV for Android from a new clean workspace. So I have chosen my OpenCV package directory for the new workspace:
+
+      .. image:: images/eclipse_1_choose_workspace.png
+         :alt: Choosing C:\Work\android-opencv\ as workspace location
+         :align: center
+
+#. Configure your ADT plugin
+
+   .. important:: ADT plugin settings are workspace-dependent. So you have to repeat this step each time when you create a new workspace.
+
+   Once you have created a new workspace, you have to point the ADT plugin to the Android SDK directory. This setting is stored in workspace metadata, as result this step is required each time when you are creating new workspace for Android development. See `Configuring the ADT Plugin
+   <http://developer.android.com/sdk/eclipse-adt.html#configuring>`_ document for the original instructions from *Google*.
+   
+   * Select :menuselection:`Window --> Preferences...` to open the Preferences panel (Mac OS X: :menuselection:`Eclipse --> Preferences`):
+
+      .. image:: images/eclipse_2_window_preferences.png
+         :height: 400px 
+         :alt: Select Window > Preferences...
+         :align: center
+   
+   * Select :guilabel:`Android` from the left panel.
+
+    You may see a dialog asking whether you want to send usage statistics to *Google*. If so, make your choice and click :guilabel:`Proceed`. You cannot continue with this procedure until you click :guilabel:`Proceed`.
+
+      .. image:: images/eclipse_3_preferences_android.png
+         :alt: Select Android from the left panel
+         :align: center
+
+   * For the SDK Location in the main panel, click :guilabel:`Browse...` and locate your Android SDK directory. 
+
+   * Click :guilabel:`Apply` button at the bottom right corner of main panel:
+
+      .. image:: images/eclipse_4_locate_sdk.png
+         :alt: Locate Android SDK
+         :align: center
+
+   * Click :guilabel:`OK` to close preferences dialog.
+   
+#. Import OpenCV and samples into workspace.
+
+   OpenCV library is packed as a ready-for-use `Android Library Project
+   <http://developer.android.com/guide/developing/projects/index.html#LibraryProjects>`_. You can simply reference it in your projects.
+   
+   Each sample included into |opencv_android_bin_pack| is a regular Android project that already references OpenCV library.
+   Follow next steps to import OpenCV and samples into workspace:
+   
+   * Right click on the :guilabel:`Package Explorer` window and choose :guilabel:`Import...` option from the context menu:
+
+      .. image:: images/eclipse_5_import_command.png
+         :alt: Select Import... from context menu
+         :align: center
+
+   * In the main panel select :menuselection:`General --> Existing Projects into Workspace` and press :guilabel:`Next` button:
+
+      .. image:: images/eclipse_6_import_existing_projects.png
+         :alt: General > Existing Projects into Workspace
+         :align: center
+
+   * For the :guilabel:`Select root directory` in the main panel locate your OpenCV package folder. (If you have created workspace in the package directory, then just click :guilabel:`Browse...` button and instantly close directory choosing dialog with :guilabel:`OK` button!) Eclipse should automatically locate OpenCV library and samples:
+
+      .. image:: images/eclipse_7_select_projects.png
+         :alt: Locate OpenCV library and samples
+         :align: center
+
+   * Click :guilabel:`Finish` button to complete the import operation.
+   
+   After clicking :guilabel:`Finish` button Eclipse will load all selected projects into workspace. And... will indicate numerous errors:
+
+      .. image:: images/eclipse_8_false_alarm.png
+         :alt: Confusing Eclipse screen with numerous errors
+         :align: center
+
+   However **all these errors are only false-alarms**!
+   
+   To help Eclipse to understand that there are no any errors choose OpenCV library in :guilabel:`Package Explorer` (left mouse click) and press :kbd:`F5` button on your keyboard. Then choose any sample (except first samples in *Tutorial Base* and *Tutorial Advanced*) and also press :kbd:`F5`.
+   
+   After this manipulation Eclipse will rebuild your workspace and error icons will disappear one after another:
+
+      .. image:: images/eclipse_9_errors_dissapearing.png
+         :alt: After small help Eclipse removes error icons!
+         :align: center
+
+   Once Eclipse completes build you will have the clean workspace without any build errors:
+
+      .. image:: images/eclipse_10_crystal_clean.png
+         :alt: OpenCV package imported into Eclipse
+         :align: center
+
+   .. note:: If you are importing only OpenCV library without samples then instead of second refresh command (:kbd:`F5`) you might need to make :menuselection:`Android Tools --> Fix Project Properties` from project context menu.
+   
+Running OpenCV Samples
+======================
+
+At this point you should be able to build and run all samples except two from Advanced tutorial (these samples require Android NDK to build working applications, see the next tutorial :ref:`Android_Binary_Package_with_NDK` to learn how to compile them).
+
+Also I want to note that only ``Tutorial 1 Basic - 0. Android Camera`` and ``Tutorial 1 Basic - 1. Add OpenCV`` samples are able to run on Emulator from Android SDK. Other samples are using OpenCV Native Camera which does not work with emulator.
+
+.. note:: Latest *Android SDK tools, revision 12* can run ARM v7 OS images but *Google* does not provide such images with SDK.
+
+Well, running samples from Eclipse is very simple:
+
+* Connect your device with :command:`adb` tool from Android SDK or create Emulator with camera support.
+
+   * See `Managing Virtual Devices
+     <http://developer.android.com/guide/developing/devices/index.html>`_ document for help with Android Emulator.
+   * See `Using Hardware Devices
+     <http://developer.android.com/guide/developing/device.html>`_ for help with real devices (not emulators).
+
+
+* Select project you want to start in :guilabel:`Package Explorer:guilabel:` and just press :kbd:`Ctrl + F11` or select option :menuselection:`Run --> Run` from main menu, or click :guilabel:`Run` button on the toolbar.
+
+  .. note:: Android Emulator can take several minutes to start. So, please, be patient.
+
+* On the first run Eclipse will ask you how to run your application:
+
+  .. image:: images/eclipse_11_run_as.png
+     :alt: Run sample as Android Application
+     :align: center
+
+* Select the :guilabel:`Android Application` option and click :guilabel:`OK` button. Eclipse will install and run the sample.
+  
+  Here is ``Tutorial 1 Basic - 1. Add OpenCV`` sample detecting edges using Canny algorithm from OpenCV:
+
+  .. image:: images/emulator_canny.png
+     :height: 600px 
+     :alt: Tutorial 1 Basic - 1. Add OpenCV - running Canny
+     :align: center
+
+
+
+How to use OpenCV library project in your application
+=====================================================
+
+If you already have an Android application, you can add a reference to OpenCV and import all its functionality. 
+
+#. First of all you need to have both projects (your app and OpenCV) in a single workspace. 
+   So, open workspace with your application and import the OpenCV project into your workspace as stated above. 
+
+#. Add a reference to OpenCV project.
+
+   Do the right mouse click on your app in Package Explorer, go to :menuselection:`Properties --> Android --> Library --> Add`
+   and choose the OpenCV library project. 
+
+Whats next?
+===========
+
+Read the :ref:`Android_Binary_Package_with_NDK` tutorial to learn how add native OpenCV code to your Android project.
+
diff --git a/doc/tutorials/introduction/android_binary_package/android_binary_package_using_with_NDK.rst b/doc/tutorials/introduction/android_binary_package/android_binary_package_using_with_NDK.rst
new file mode 100644
index 0000000000..ef5c917611
--- /dev/null
+++ b/doc/tutorials/introduction/android_binary_package/android_binary_package_using_with_NDK.rst
@@ -0,0 +1,377 @@
+
+
+.. _Android_Binary_Package_with_NDK:
+
+
+Using C++ OpenCV code with Android binary package
+*************************************************
+
+The Android way is writing all your code in Java. But somethimes it is not enough and you need to go to a native level and write part of your application in C/C++.
+This is important when you already have some computer vision functionality which is written in C++ and uses OpenCV, and you want to use it in your Android application,
+but do not want to rewrite the C++ code to Java. 
+In this case the only way is to use JNI mechanism. 
+It means, that you should add a class with native methods wrapping your C++ functionality into the Java part of your Android application.
+
+This tutorial describes a fast way how to create and build Android applications containing OpenCV code written in C++. It shows how to build an application which uses OpenCV inside its JNI calls.
+
+Please note that before starting this tutorial you should fulfill all the steps, described in the tutorial :ref:`Android_Binary_Package`.
+
+This tutorial was tested using Ubuntu 10.04 and Windows 7 SP1 operating systems. 
+Nevertheless, it should also work on Mac OS X. If you encounter errors after following the steps described here, feel free to contact us via *android-opencv* discussion group https://groups.google.com/group/android-opencv/ and we will try to help you.
+
+
+Prerequisites: Setup NDK
+========================
+
+To compile C++ code for Android platform you need Android **N**\ ative **D**\ evelopment **K**\ it (*NDK*).
+
+You can get the latest version of NDK from the page http://developer.android.com/sdk/ndk/index.html .
+
+To install Android NDK just extract the archive to some folder on your computer. (Here is installation instructions on the NDK home page: http://developer.android.com/sdk/ndk/index.html#installing)
+
+.. note:: Before start you can read official Android NDK documentation which is in the Android NDK archive, in the folder :file:`docs/`.
+
+    The main article about using Android NDK build system you can read in the file :file:`ANDROID-MK.html`. 
+
+    Also some additional useful information you can read in the files
+    :file:`APPLICATION-MK.html`, :file:`NDK-BUILD.html`, and in the files :file:`CPU-ARM-NEON.html`, :file:`CPLUSPLUS-SUPPORT.html`,  :file:`PREBUILTS.html`. 
+
+Theory: Android application structure
+=====================================
+
+Usually code of an Android application has the following structure:
+
++ :file:`root folder of the project/`
+
+  - :file:`jni/`
+
+  - :file:`libs/`
+
+  - :file:`res/`
+
+  - :file:`src/`
+
+  - :file:`AndroidManifest.xml`
+
+  - :file:`default.properties`
+
+  - :file:`... other files ...`
+
+where
+
++ the :file:`src` folder contains Java code of the application,
+
++ the :file:`res` folder contains resources of the application (images, xml files describing UI layout , etc),
+
++ the :file:`libs` folder will contain native libraries after successful build,
+
++ and the :file:`jni` folder contains C/C++ application source code and NDK's build scripts :file:`Android.mk` and :file:`Application.mk`.
+   
+  These scripts control the C++ build process (they are written in Makefile language). 
+
+
+Also the root folder should contain the following files 
+
+* :file:`AndroidManifest.xml` file presents essential information about application to the Android system 
+  (name of the Application, name of main application's package, components of the application, required permissions, etc) 
+  
+  It can be created using Eclipse wizard or :command:`android` tool from Android SDK
+
+* :file:`default.properties` is a text file containing information about target Android platform and other build details.
+  
+  This file is generated by Eclipse or can be created with :command:`android` tool from Android SDK
+
+.. note:: Both files (:file:`AndroidManifest.xml` and :file:`default.properties`) are required to compile the C++ part of the application (NDK build system uses information from these files). If any of these files does not exist, compile the Java part of the project before the C++ part. 
+
+
+Theory: How to build Android application having C++ native part (from command line)
+===================================================================================
+
+Here is the standard way to compile C++ part of an Android application: 
+
+#. Open console and go to the root folder of Android application
+
+   .. code-block:: bash
+
+        cd <root folder of the project>/
+
+   .. note:: Alternatively you can go to the folder :file:`jni` of Android project but samples from OpenCV binary package are configured for building from project root level (because of relative path to the OpenCV library).
+
+#. Run the following command
+
+   .. code-block:: bash
+
+        <path_where_NDK_is_placed>/ndk-build
+
+   .. note:: If you are working in *cygwin* shell and encounter an error saying that NDK does not find some *cygwin*\ 's path then you might need to define the following environment variable:
+
+       .. code-block:: bash
+
+            export NDK_USE_CYGPATH=1
+
+#.   After executing this command the C++ part of the source code is compiled.
+
+After that the Java part of the application can be (re)compiled (using either *Eclipse* or :command:`ant` build tool). 
+
+.. note:: Some parameters can be set for the :command:`ndk-build`:
+
+    **Example 1**: Verbose compilation
+
+    .. code-block:: bash
+
+        <path_where_NDK_is_placed>/ndk-build V=1
+
+    **Example 2**: Rebuild all
+
+    .. code-block:: bash
+
+        <path_where_NDK_is_placed>/ndk-build -B
+
+
+.. _Android_NDK_integration_with_Eclipse:
+
+
+Theory: How to build Android application having C++ native part (from *Eclipse*)
+================================================================================
+
+There are several possible ways to integrate compilation of C++ code by Android NDK into Eclipse compilation process. We recommend the approach taken from this site: http://mobilepearls.com/labs/ndk-builder-in-eclipse/
+
+.. important:: This instructions should be applied for each Android project in *Eclipse* workspace. So if you have 3 projects having C++ part then you need to configure 3 builders.
+
+Below is an adapted version of this guide:
+
+#. Navigate to :guilabel:`Package Explorer` window and expand your project having JNI resources.
+
+   If you can not see :file:`libs` folder under this project then you need to create it manually. (It will be required on step 7, but you need to create it before you open project properties.)
+
+#. Right click on your project in :guilabel:`Package Explorer` window and select :guilabel:`Properties`.
+
+#. In the :guilabel:`Properties` dialog select :guilabel:`Builders` menu and press the :guilabel:`New...` button:
+
+     .. image:: images/eclipse_builders.png
+        :alt: Configure builders
+        :align: center
+
+#. In the resulting dialog select the :guilabel:`Program` type and press :guilabel:`OK` button:
+
+     .. image:: images/eclipse_builder_types.png
+        :alt: Choose builder type
+        :align: center
+
+#. In the :guilabel:`Main` tab fill the following fields:
+
+    * :guilabel:`Name` - any name for your builder. ("Tutorial 2.1 Builder" in my case.)
+
+      .. note:: This name has to be unique for each project in your workspace.
+
+    * :guilabel:`Location` - full path to :command:`ndk-build` tool.
+
+      + *UNIX*
+
+        Just put full path to :command:`ndk-build` into this filed. Also you can add some options to the :guilabel:`Arguments:guilabel:` fied, for example ``-B`` option.
+
+      + *Cygwin*
+
+        - Instead of path to the :command:`ndk-build` tool you need to put full path to *cygwin*\ 's :program:`bash.exe` location. E.g: :file:`C:\\cygwin\\bin\\bash.exe`.
+
+        - Put full path to :command:`ndk-build` into the :guilabel:`Arguments` field E.g. :file:`C:\\Android\\android-ndk-r6\\ndk-build`.
+
+        - Go to the :guilabel:`Environment` tab and define an environment variable:
+             
+           * :envvar:`PATH` - full path to the *cygwin* tools. E.g. :file:`C:\\cygwin\\bin`
+    
+     .. image:: images/eclipse_windows_environment.png
+                :alt: Define environment variables
+                :align: center
+
+    * :guilabel:`Working Directory` - put path to your project into this field. Instead of hardcoding full path you can click :guilabel:`Browse Workspace...` button and select your project.
+
+     .. image:: images/eclipse_edit_configuration_main.png
+                :alt: Define environment variables
+                :align: center
+
+#. Go to the :guilabel:`Refresh` tab and select both :guilabel:`Refresh resources upon completion` and :guilabel:`Recursively include sub-folders`.
+
+   Next set the :guilabel:`Specific resources` option and click :guilabel:`Specify resources...` button:
+
+    .. image:: images/eclipse_edit_configuration_refresh.png
+               :alt: Define environment variables
+               :align: center
+
+#. Select :file:`libs` folder under your project and click :guilabel:`Finish`:
+
+    .. image:: images/eclipse_edit_configuration_specify_resources.png
+               :alt: Select resources folder to refresh automatically 
+               :align: center
+
+#. Go to the last tab :guilabel:`Build options`. Make sure that all checkboxes are set as shown on the next screen:
+
+    .. image:: images/eclipse_edit_configuration_build_options.png
+               :alt: Configure build options
+               :align: center
+
+#. Next, click the :guilabel:`Specify resources...` button.
+
+#. Select :file:`jni` folder of your project and click the :guilabel:`Finish` button:
+
+    .. image:: images/eclipse_edit_configuration_build_resources.png
+               :alt: Select resources to build
+               :align: center
+
+#. Finally press :guilabel:`OK` in the builder configuration and project properties dialogs. If you have automatic build turned on then console showing build log should appear:
+
+    .. image:: images/eclipse_NDK_build_success.png
+               :alt: Select resources to build
+               :align: center
+
+Theory: The structure of :file:`Android.mk` and :file:`Application.mk` scripts
+==============================================================================
+
+The script :file:`Android.mk` usually have the following structure: 
+
+.. code-block:: make
+
+        LOCAL_PATH := $(call my-dir)
+
+        include $(CLEAR_VARS)
+        LOCAL_MODULE    := <module_name>
+        LOCAL_SRC_FILES := <list of .c and .cpp project files>
+        <some variable name> := <some variable value>
+        ...
+        <some variable name> := <some variable value>
+
+        include $(BUILD_SHARED_LIBRARY)
+
+This is the minimal file :file:`Android.mk`, which builds a C++ source code of an Android application. Note that the first two lines and the last line are mandatory for any :file:`Android.mk`.
+
+Usually the file :file:`Application.mk` is optional, but in case of project using OpenCV, when STL and exceptions are used in C++, it also should be written. Example of the file :file:`Application.mk`:
+
+.. code-block:: make
+
+        APP_STL := gnustl_static
+        APP_CPPFLAGS := -frtti -fexceptions
+        APP_ABI := armeabi-v7a
+
+Practice: Build samples from OpenCV binary package
+==================================================
+
+OpenCV binary package includes two samples having JNI resources:
+
+* *Tutorial 2 Advanced - 1. Add Native OpenCV*
+  
+  This sample illustrate how you can use OpenCV in C++ but without OpenCV Java API.
+
+* *Tutorial 2 Advanced - 2. Mix Java+Native OpenCV*
+
+  This sample shows how you can mix OpenCV Java API and native C++ code.
+
+To build these samples you need to:
+
+#. Fulfill all the steps, described in the tutorial :ref:`Android_Binary_Package`.
+
+#. Setup one builder for *"Tutorial 2 Advanced - 1. Add Native OpenCV"* project (as described in :ref:`Android_NDK_integration_with_Eclipse`)
+
+#. Setup second builder for *"Tutorial 2 Advanced - 2. Mix Java+Native OpenCV"* project (repeat the steps from :ref:`Android_NDK_integration_with_Eclipse`)
+
+#. Clean these projects (in the main Eclipse menu: :menuselection:`Project --> Clean...`)
+
+#. Run Eclipse build command (if option :guilabel:`Build Automatically` is not set)
+
+
+Practice: Create an Android application, which uses OpenCV
+==========================================================
+
+To build your own Android application, which uses OpenCV from native part, the following steps should be done:
+
+#. The archive with OpenCV binary package should be downloaded and extracted to some folder (as example, into the home folder)
+
+#. We recommend to use an environment variable to specify the location of OpenCV package. Full or relative path hardcoded in :file:`jni/Android.mk` will also work.
+
+   So, the environment variable :envvar:`OPENCV_PACKAGE_DIR` should be defined. 
+   The value of the variable should points to the folder, where the OpenCV package has been extracted. 
+
+
+   As an example, on *UNIX* you can add add the following line into the hidden file :file:`.bashrc` placed in your home folder: 
+   
+   .. code-block:: bash
+
+        export OPENCV_PACKAGE_DIR = <path to the extracted OpenCV package>
+        
+   Then relogin (or better reboot your computer).
+   
+   .. attention:: without rebooting (or logout) this change might not work.
+
+   If you are a *Windows* user, then navigate to:
+
+   * *Windows 7 / Windows Vista*
+
+     :menuselection:`My Computer (Right Click on Icon) --> Properties (Link) --> Advanced System Settings (Link) --> Advanced (Tab) --> Environment Variables (Button) --> System variables (Section)`
+
+   * *Windows XP*
+
+     :menuselection:`My Computer (Right Click on Icon) --> Properties (Link) --> Advanced (Tab) --> Environment Variables (Button) --> System variables (Section)`
+
+   Create new variable :envvar:`OPENCV_PACKAGE_DIR` and similarly to *UNIX* relogin or reboot.
+
+   If you are setting NDK builder as described above in :ref:`Android_NDK_integration_with_Eclipse`, then you can define this variable in builder settings. It can be done on third :guilabel:`Environment` tab of the builder configuration window (we have already added some variables to this tab on *Windows* but skipped it for other platforms). 
+
+#.  The file :file:`jni/Android.mk` should be written for the current application using the common rules for the file.
+
+    For detailed information see the Android NDK documentation from the Android NDK archive, in the file
+    :file:`<path_where_NDK_is_placed>/docs/ANDROID-MK.html`
+
+#. The line 
+
+   .. code-block:: make
+
+           include $(OPENCV_PACKAGE_DIR)/share/OpenCV/OpenCV.mk
+
+   should be inserted into the :file:`jni/Android.mk` file right after the line
+
+   .. code-block:: make
+
+        include $(CLEAR_VARS)
+
+   .. note:: If your application utilize both native (C++) OpenCV and its Java API you need to put the following line before including :file:`OpenCV.mk` to avoid conflict between C++ and Java builders:
+
+       .. code-block:: make
+
+            OPENCV_CAMERA_MODULES:=off
+
+#. The file :file:`Application.mk` should exist and should contain lines
+
+   .. code-block:: make
+
+        APP_STL := gnustl_static 
+        APP_CPPFLAGS := -frtti -fexceptions
+
+   Also the line
+
+   .. code-block:: make
+
+                 APP_ABI := armeabi-v7a 
+
+   is recommended for the applications targeting modern ARMs 
+   
+#. To build the C++ code the Android NDK script :command:`ndk-build` should be run in the root directory of application. 
+   Then the C++ source code using OpenCV will be built by Android NDK build system. 
+   After that the Java part of the application can be rebuild and the application can be installed on an Android device. 
+
+   Note that this step requires calling the :command:`ndk-build` script from the console. Instead of this step you can use integration of Android NDK into Eclipse
+   as stated above in  the section :ref:`Android_NDK_integration_with_Eclipse` .
+
+
+Additional C++ support in Eclipse
+==================================
+
+Note that you can install additional C++ plugins in Eclipse:
+
+#. Open :guilabel:`Help / Install New Software`. This shows the :guilabel:`Install` dialog.
+
+#. In the :guilabel:`Work with` drop-down list choose :guilabel:`Helios - http://download.eclipse.org/releases/helios` (or :guilabel:`Indigo - http://download.eclipse.org/releases/indigo` depending on your Eclipse version) and wait while the list of available software is loaded.
+
+#. From the list of available software select :menuselection:`Programming Languages --> C/C++ Development Tools`.
+
+#. Click :guilabel:`Next`, click :guilabel:`Next` again, accept the agreement, and click the :guilabel:`Finish` button.
+
+#. When installation is finished, click :guilabel:`Reload`
diff --git a/doc/tutorials/introduction/android_binary_package/images/android_package_7zip.png b/doc/tutorials/introduction/android_binary_package/images/android_package_7zip.png
new file mode 100644
index 0000000000..7de853b88e
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/android_package_7zip.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/android_sdk_and_avd_manager.png b/doc/tutorials/introduction/android_binary_package/images/android_sdk_and_avd_manager.png
new file mode 100644
index 0000000000..dd47b4714d
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/android_sdk_and_avd_manager.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_10_crystal_clean.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_10_crystal_clean.png
new file mode 100644
index 0000000000..3cc22df89e
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_10_crystal_clean.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_11_run_as.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_11_run_as.png
new file mode 100644
index 0000000000..af3582aa19
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_11_run_as.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_1_choose_workspace.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_1_choose_workspace.png
new file mode 100644
index 0000000000..ad7384e096
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_1_choose_workspace.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_2_window_preferences.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_2_window_preferences.png
new file mode 100644
index 0000000000..de75dd02e1
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_2_window_preferences.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_3_preferences_android.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_3_preferences_android.png
new file mode 100644
index 0000000000..93f7038e2a
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_3_preferences_android.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_4_locate_sdk.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_4_locate_sdk.png
new file mode 100644
index 0000000000..eb8a347cb1
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_4_locate_sdk.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_5_import_command.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_5_import_command.png
new file mode 100644
index 0000000000..9827b92d51
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_5_import_command.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_6_import_existing_projects.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_6_import_existing_projects.png
new file mode 100644
index 0000000000..7f9a358ea7
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_6_import_existing_projects.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_7_select_projects.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_7_select_projects.png
new file mode 100644
index 0000000000..69cddec4dd
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_7_select_projects.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_8_false_alarm.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_8_false_alarm.png
new file mode 100644
index 0000000000..3dff24a22f
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_8_false_alarm.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_9_errors_dissapearing.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_9_errors_dissapearing.png
new file mode 100644
index 0000000000..7dadcbc39f
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_9_errors_dissapearing.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_NDK_build_success.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_NDK_build_success.png
new file mode 100644
index 0000000000..0bf2a85287
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_NDK_build_success.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_builder_types.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_builder_types.png
new file mode 100644
index 0000000000..61673a3699
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_builder_types.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_builders.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_builders.png
new file mode 100644
index 0000000000..69d90d839d
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_builders.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_options.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_options.png
new file mode 100644
index 0000000000..9a4683d5bf
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_options.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_resources.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_resources.png
new file mode 100644
index 0000000000..9c3480ea76
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_build_resources.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_main.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_main.png
new file mode 100644
index 0000000000..4c3bea0c86
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_main.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_refresh.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_refresh.png
new file mode 100644
index 0000000000..4e36593b98
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_refresh.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_specify_resources.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_specify_resources.png
new file mode 100644
index 0000000000..bce08a8831
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_edit_configuration_specify_resources.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/eclipse_windows_environment.png b/doc/tutorials/introduction/android_binary_package/images/eclipse_windows_environment.png
new file mode 100644
index 0000000000..5deced55c9
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/eclipse_windows_environment.png differ
diff --git a/doc/tutorials/introduction/android_binary_package/images/emulator_canny.png b/doc/tutorials/introduction/android_binary_package/images/emulator_canny.png
new file mode 100644
index 0000000000..24f2b98c17
Binary files /dev/null and b/doc/tutorials/introduction/android_binary_package/images/emulator_canny.png differ
diff --git a/doc/tutorials/introduction/display_image/display_image.rst b/doc/tutorials/introduction/display_image/display_image.rst
index 72fe5c1767..a8be339867 100644
--- a/doc/tutorials/introduction/display_image/display_image.rst
+++ b/doc/tutorials/introduction/display_image/display_image.rst
@@ -1,112 +1,127 @@
 .. _Display_Image:
 
-Display an Image
-*****************
+Load and Display an Image
+*************************
 
 Goal
 =====
 
 In this tutorial you will learn how to:
 
-* Load an image using :imread:`imread <>`
-* Create a named window (using :named_window:`namedWindow <>`)
-* Display an image in an OpenCV window (using :imshow:`imshow <>`)
+.. container:: enumeratevisibleitemswithsquare
+   
+   * Load an image (using :imread:`imread <>`)
+   * Create a named OpenCV window (using :named_window:`namedWindow <>`)
+   * Display an image in an OpenCV window (using :imshow:`imshow <>`)
 
-Code
-=====
+Source Code
+===========
 
-Here it is:
-
-.. code-block:: cpp
-
-   #include <cv.h>
-   #include <highgui.h>
-
-   using namespace cv;
-
-   int main( int argc, char** argv )
-   {
-    Mat image;
-    image = imread( argv[1], 1 );
-
-    if( argc != 2 || !image.data )
-      { 
-        printf( "No image data \n" );
-        return -1; 
-      }
-
-    namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
-    imshow( "Display Image", image );
-
-    waitKey(0);
-
-    return 0;
-   }
+Download the :download:`source code from here <../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp>` or look it up in our library at :file:`samples/cpp/tutorial_code/introduction/display_image/display_image.cpp`.
 
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :tab-width: 4
+   :linenos:
 
 Explanation
 ============
 
-#. .. code-block:: cpp
+In OpenCV 2 we have multiple modules. Each one takes care of a different area or approach towards image processing. You could already observe this in the structure of the user guide of these tutorials itself. Before you use any of them you first need to include the header files where the content of each individual module is declared.
 
-      #include <cv.h>
-      #include <highgui.h>
-   
-      using namespace cv;
+You'll almost always end up using the: 
 
-   These are OpenCV headers:
+.. container:: enumeratevisibleitemswithsquare
 
-   * *cv.h* : Main OpenCV functions
-   * *highgui.h* : Graphical User Interface (GUI) functions
+   + *core* section, as here are defined the basic building blocks of the library
+   + *highgui* module, as this contains the functions for input and output operations
 
-   Now, let's analyze the *main* function:
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines:  1-3
 
-#. .. code-block:: cpp 
+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:
 
-      Mat image;
-   
-   We create a Mat object to store the data of the image to load.
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines:  5-6
 
-#. .. code-block:: cpp
-    
-      image = imread( argv[1], 1 );
+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.
 
-   Here, we called the function :imread:`imread <>` which basically loads the image specified by the first argument (in this case *argv[1]*). The second argument is by default.
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 10-14
 
-#. After checking that the image data was loaded correctly, we want to display our image, so we create a window:
+Then create a *Mat* object that will store the data of the loaded image.
 
-   .. code-block:: cpp
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 16
 
-      namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
+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:
 
+.. container:: enumeratevisibleitemswithsquare
 
-   :named_window:`namedWindow <>` receives as arguments the window name ("Display Image") and an additional argument that defines windows properties. In this case **CV_WINDOW_AUTOSIZE** indicates that the window will adopt the size of the image to be displayed.
+   + CV_LOAD_IMAGE_UNCHANGED (<0) loads the image as is (including the alpha channel if present)
+   + CV_LOAD_IMAGE_GRAYSCALE ( 0) loads the image as an intensity one
+   + CV_LOAD_IMAGE_COLOR     (>0) loads the image in the RGB format
 
-#. Finally, it is time to show the image, for this we use :imshow:`imshow <>` 
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :tab-width: 4
+   :lines: 17
 
-   .. code-block:: cpp
-  
-      imshow( "Display Image", image )
+.. note:: 
 
-#. Finally, we want our window to be displayed until the user presses a key (otherwise the program would end far too quickly):
+   OpenCV offers support for the image formats Windows bitmap (bmp), portable image formats (pbm, pgm, ppm) and Sun raster (sr, ras). With help of plugins (you need to specify to use them if you build yourself the library, nevertheless in the packages we ship present by default) you may also load image formats like JPEG (jpeg, jpg, jpe), JPEG 2000 (jp2 - codenamed in the CMake as Jasper), TIFF files (tiff, tif) and portable network graphics (png). Furthermore, OpenEXR is also a possibility. 
 
-   .. code-block:: cpp
- 
-      waitKey(0);
+After checking that the image data was loaded correctly, we want to display our image, so we create an OpenCV window using the :named_window:`namedWindow <>` function. These are automatically managed by OpenCV once you create them. For this you need to specify its name and how it should handle the change of the image it contains from a size point of view. It may be: 
 
-   We use the :wait_key:`waitKey <>` function, which allow us to wait for a keystroke during a number of milliseconds (determined by the argument). If the argument is zero, then it will wait indefinitely.
+.. container:: enumeratevisibleitemswithsquare
+
+   + *CV_WINDOW_AUTOSIZE* is the only supported one if you do not use the Qt backend. In this case the window size will take up the size of the image it shows. No resize permitted! 
+   + *CV_WINDOW_NORMAL* on Qt you may use this to allow window resize. The image will resize itself according to the current window size. By using the | operator you also need to specify if you would like the image to keep its aspect ratio (*CV_WINDOW_KEEPRATIO*) or not (*CV_WINDOW_FREERATIO*). 
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
+   :language: cpp
+   :lines: 25
+   :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
+   :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
+   :tab-width: 4
 
 Result
 =======
 
-* Compile your code and then run the executable giving a image path as argument:
+* Compile your code and then run the executable giving an image path as argument. If you're on Windows the executable will of course contain an *exe* extension too. Of course assure the image file is near your program file. 
 
   .. code-block:: bash
- 
+
      ./DisplayImage HappyFish.jpg
 
 * You should get a nice window as the one shown below:
 
-  .. image:: images/Display_Image_Tutorial_Result.png
+  .. image:: images/Display_Image_Tutorial_Result.jpg
      :alt: Display Image Tutorial - Final Result
      :align: center 
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Introduction - Display an Image" width="560" height="349" src="http://www.youtube.com/embed/1OJEqpuaGc4?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
diff --git a/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.jpg b/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.jpg
new file mode 100644
index 0000000000..16400698f0
Binary files /dev/null and b/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.png b/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.png
deleted file mode 100644
index 62e3878e03..0000000000
Binary files a/doc/tutorials/introduction/display_image/images/Display_Image_Tutorial_Result.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-0.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-0.png
deleted file mode 100644
index 3ad10d4920..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-0.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-1.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-1.png
deleted file mode 100644
index 31c284a1a9..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-1.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-10.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-10.png
deleted file mode 100644
index 48bf684ab1..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-10.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-11.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-11.png
deleted file mode 100644
index edca4abe13..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-11.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-12.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-12.png
deleted file mode 100644
index 47f1fe432d..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-12.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-13.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-13.png
deleted file mode 100644
index 2a2d9b3ad0..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-13.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-14.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-14.png
deleted file mode 100644
index 6cd7878d43..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-14.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-15.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-15.png
deleted file mode 100644
index 337fd00309..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-15.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-2.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-2.png
deleted file mode 100644
index ddb86ea7c3..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-2.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-3.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-3.png
deleted file mode 100644
index 0bfad99975..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-3.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-4.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-4.png
deleted file mode 100644
index 8a1e2c4a3e..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-4.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-5.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-5.png
deleted file mode 100644
index ba5504a925..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-5.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-6.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-6.png
deleted file mode 100644
index 0b16972a10..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-6.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-7.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-7.png
deleted file mode 100644
index b9aa3187e4..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-7.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-8.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-8.png
deleted file mode 100644
index 800f67b653..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-8.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-9.png b/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-9.png
deleted file mode 100644
index e56b28c375..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/Eclipse_Tutorial_Screenshot-9.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a0.png b/doc/tutorials/introduction/linux_eclipse/images/a0.png
new file mode 100644
index 0000000000..00577b7e48
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a0.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a1.png b/doc/tutorials/introduction/linux_eclipse/images/a1.png
new file mode 100644
index 0000000000..edbb69ea45
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a1.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a10.png b/doc/tutorials/introduction/linux_eclipse/images/a10.png
new file mode 100644
index 0000000000..d3603ba75d
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a10.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a12.png b/doc/tutorials/introduction/linux_eclipse/images/a12.png
new file mode 100644
index 0000000000..4838501d5b
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a12.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a14.png b/doc/tutorials/introduction/linux_eclipse/images/a14.png
new file mode 100644
index 0000000000..7db82993b0
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a14.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a15.jpg b/doc/tutorials/introduction/linux_eclipse/images/a15.jpg
new file mode 100644
index 0000000000..4f1fa43716
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a15.jpg differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a3.png b/doc/tutorials/introduction/linux_eclipse/images/a3.png
new file mode 100644
index 0000000000..53f700e00c
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a3.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a4.png b/doc/tutorials/introduction/linux_eclipse/images/a4.png
new file mode 100644
index 0000000000..fc1eb71008
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a4.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a7.png b/doc/tutorials/introduction/linux_eclipse/images/a7.png
new file mode 100644
index 0000000000..a87d6eb41b
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a7.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/a9.png b/doc/tutorials/introduction/linux_eclipse/images/a9.png
new file mode 100644
index 0000000000..0e34c7e1a7
Binary files /dev/null and b/doc/tutorials/introduction/linux_eclipse/images/a9.png differ
diff --git a/doc/tutorials/introduction/linux_eclipse/images/eclipse_cpp_logo.jpeg b/doc/tutorials/introduction/linux_eclipse/images/eclipse_cpp_logo.jpeg
deleted file mode 100644
index f1aecfe85b..0000000000
Binary files a/doc/tutorials/introduction/linux_eclipse/images/eclipse_cpp_logo.jpeg and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst b/doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst
index 38cd647b23..2d300f0100 100644
--- a/doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst
+++ b/doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst
@@ -1,247 +1,260 @@
-.. _Linux_Eclipse_Usage:
-
-Using OpenCV with Eclipse (plugin CDT)
-****************************************
-
-.. note::
-   For me at least, this works, is simple and quick. Suggestions are welcome
-
-Prerequisites
-===============
-
-#. Having installed `Eclipse <http://www.eclipse.org/>`_ in your workstation (only the CDT plugin for C/C++ is needed). You can follow the following steps:
-
-   * Go to the Eclipse site  
-
-   * Download `Eclipse IDE for C/C++ Developers <http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliossr2>`_ . Choose the link according to your workstation.
-
-#. Having installed OpenCV. If not yet, go :ref:`here <Linux_Installation>`
-
-Making a project
-=================
-
-#. Start Eclipse. Just run the executable that comes in the folder. 
-
-#. Go to **File -> New -> C/C++ Project**
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-0.png
-      :height: 400px 
-      :alt: Eclipse Tutorial Screenshot 0
-      :align: center
-
-#. Choose a name for your project (i.e. DisplayImage). An **Empty Project** should be okay for this example. 
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-1.png
-      :height: 400px 
-      :alt: Eclipse Tutorial Screenshot 1
-      :align: center
-
-#. Leave everything else by default. Press **Finish**. 
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-2.png
-      :height: 400px 
-      :alt: Eclipse Tutorial Screenshot 2
-      :align: center
-
-#. Your project (in this case DisplayImage) should appear in the **Project Navigator** (usually at the left side of your window).
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-3.png
-      :height: 400px 
-      :alt: Eclipse Tutorial Screenshot 3
-      :align: center
-
-
-#. Now, let's add a source file using OpenCV:
-
-   * Right click on **DisplayImage** (in the Navigator). **New -> Folder** . 
-
-     .. image:: images/Eclipse_Tutorial_Screenshot-4.png
-        :height: 400px 
-        :alt: Eclipse Tutorial Screenshot 4
-        :align: center
-
-   * Name your folder **src** and then hit **Finish**
-
-     .. image:: images/Eclipse_Tutorial_Screenshot-5.png
-        :height: 400px 
-        :alt: Eclipse Tutorial Screenshot 5
-        :align: center
-
-   * Right click on your newly created **src** folder. Choose **New source file**:
-
-     .. image:: images/Eclipse_Tutorial_Screenshot-6.png
-        :height: 400px 
-        :alt: Eclipse Tutorial Screenshot 6
-        :align: center
-
-   * Call it **DisplayImage.cpp**. Hit **Finish**
-
-     .. image:: images/Eclipse_Tutorial_Screenshot-7.png
-        :height: 400px 
-        :alt: Eclipse Tutorial Screenshot 7
-        :align: center
-
-#. So, now you have a project with a empty .cpp file. Let's fill it with some sample code (in other words, copy and paste the snippet below):
-
-   .. code-block:: cpp
-
-      #include <cv.h>
-      #include <highgui.h>
-
-      using namespace cv;
-
-      int main( int argc, char** argv )
-      {
-        Mat image;
-        image = imread( argv[1], 1 );
-
-        if( argc != 2 || !image.data )
-          { 
-            printf( "No image data \n" );
-            return -1; 
-          }
-
-        namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
-        imshow( "Display Image", image );
-
-        waitKey(0);
-
-        return 0;
-      }
-
-#. We are only missing one final step: To tell OpenCV where the OpenCV headers and libraries are. For this, do the following:
-
-    *
-      Go to  **Project-->Properties**
-
-      .. image:: images/Eclipse_Tutorial_Screenshot-8.png
-         :height: 400px 
-         :alt: Eclipse Tutorial Screenshot 8
-         :align: center
-
-    *
-      In **C/C++ Build**, click on **Settings**. At the right, choose the **Tool Settings** Tab. Here we will enter the headers and libraries info:
-
-      a.
-        In **GCC C++ Compiler**, go to **Includes**. In **Include paths(-l)** you should include the path of the folder where opencv was installed. In our example, this is ``/usr/local/include/opencv``.
-
-         .. image:: images/Eclipse_Tutorial_Screenshot-9.png
-            :height: 400px 
-            :alt: Eclipse Tutorial Screenshot 9
-            :align: center
-
-         .. note::
-            If you do not know where your opencv files are, open the **Terminal** and type: 
-
-            .. code-block:: bash
-            
-               pkg-config --cflags opencv
-
-            For instance, that command gave me this output:
-
-            .. code-block:: bash
-
-               -I/usr/local/include/opencv -I/usr/local/include 
-
-        
-      b.
-        Now go to **GCC C++ Linker**,there you have to fill two spaces:
-
-          * In **Library search path (-L)** you have to write the path to where the opencv libraries reside, in my case the path is:
-            ::
-          
-                /usr/local/lib
-                
-            ..
-
-          *
-            In **Libraries(-l)** add the OpenCV libraries that you may need. Usually just the 3 first on the list below are enough (for simple applications) . In my case, I am putting all of them since I plan to use the whole bunch:
-
-
-              * opencv_core      
-              * opencv_imgproc     
-              * opencv_highgui
-              * opencv_ml       
-              * opencv_video      
-              * opencv_features2d
-              * opencv_calib3d   
-              * opencv_objdetect   
-              * opencv_contrib
-              * opencv_legacy    
-              * opencv_flann
-          
-            .. image:: images/Eclipse_Tutorial_Screenshot-10.png
-               :height: 400px 
-               :alt: Eclipse Tutorial Screenshot 10
-               :align: center 
-
-            .. note::
-
-               If you don't know where your libraries are (or you are just psychotic and want to make sure the path is fine), type in **Terminal**:
-
-               .. code-block:: bash
-            
-                  pkg-config --libs opencv
-
-               My output (in case you want to check) was:
-
-               .. code-block:: bash
-
-                  -L/usr/local/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann  
-
-            Now you are done. Click **OK**
-
-    * Your project should be ready to be built. For this, go to **Project->Build all**   
- 
-      .. image:: images/Eclipse_Tutorial_Screenshot-11.png
-         :height: 400px 
-         :alt: Eclipse Tutorial Screenshot 11
-         :align: center 
-
-      In the Console you should get something like 
-
-      .. image:: images/Eclipse_Tutorial_Screenshot-12.png
-         :height: 200px 
-         :alt: Eclipse Tutorial Screenshot 12
-         :align: center 
-
-      If you check in your folder, there should be an executable there.
-
-Running the executable
-========================
-
-So, now we have an executable ready to run. If we were to use the Terminal, we would probably do something like:
-
-.. code-block:: bash
-
-   cd <DisplayImage_directory>
-   cd src
-   ./DisplayImage ../images/HappyLittleFish.jpg
-  
-Assuming that the image to use as the argument would be located in <DisplayImage_directory>/images/HappyLittleFish.jpg. We can still do this, but let's do it from Eclipse:
-
-
-#. Go to **Run->Run Configurations** 
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-13.png
-      :height: 300px 
-      :alt: Eclipse Tutorial Screenshot 13
-      :align: center 
-
-#. Under C/C++ Application you will see the name of your executable + Debug (if not, click over C/C++ Application a couple of times). Select the name (in this case **DisplayImage Debug**). 
-
-#. Now, in the right side of the window, choose the **Arguments** Tab. Write the path of the image file we want to open (path relative to the workspace/DisplayImage folder). Let's use **HappyLittleFish.jpg**:
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-14.png
-      :height: 300px 
-      :alt: Eclipse Tutorial Screenshot 14
-      :align: center 
-
-#. Click on the **Apply** button and then in Run. An OpenCV window should pop up with the fish image (or whatever you used).
-
-   .. image:: images/Eclipse_Tutorial_Screenshot-15.png
-      :alt: Eclipse Tutorial Screenshot 15
-      :align: center 
-
-
-#. Congratulations! You are ready to have fun with OpenCV using Eclipse.
+.. _Linux_Eclipse_Usage:
+
+Using OpenCV with Eclipse (plugin CDT)
+****************************************
+
+.. note::
+   Two ways, one by forming a project directly, and another by CMake
+
+Prerequisites
+===============
+
+1. Having installed `Eclipse <http://www.eclipse.org/>`_ in your workstation (only the CDT plugin for C/C++ is needed). You can follow the following steps:
+
+   * Go to the Eclipse site  
+
+   * Download `Eclipse IDE for C/C++ Developers <http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliossr2>`_ . Choose the link according to your workstation.
+
+#. Having installed OpenCV. If not yet, go :ref:`here <Linux-Installation>`.
+
+Making a project
+=================
+
+1. Start Eclipse. Just run the executable that comes in the folder. 
+
+#. Go to **File -> New -> C/C++ Project**
+
+   .. image:: images/a0.png
+      :alt: Eclipse Tutorial Screenshot 0
+      :align: center
+
+#. Choose a name for your project (i.e. DisplayImage). An **Empty Project** should be okay for this example. 
+
+   .. image:: images/a1.png
+      :alt: Eclipse Tutorial Screenshot 1
+      :align: center
+
+#. Leave everything else by default. Press **Finish**. 
+
+#. Your project (in this case DisplayImage) should appear in the **Project Navigator** (usually at the left side of your window).
+
+   .. image:: images/a3.png
+      :alt: Eclipse Tutorial Screenshot 3
+      :align: center
+
+
+#. Now, let's add a source file using OpenCV:
+
+   * Right click on **DisplayImage** (in the Navigator). **New -> Folder** . 
+
+     .. image:: images/a4.png
+        :alt: Eclipse Tutorial Screenshot 4
+        :align: center
+
+   * Name your folder **src** and then hit **Finish**
+
+   * Right click on your newly created **src** folder. Choose **New source file**:
+
+   * Call it **DisplayImage.cpp**. Hit **Finish**
+
+     .. image:: images/a7.png
+        :alt: Eclipse Tutorial Screenshot 7
+        :align: center
+
+#. So, now you have a project with a empty .cpp file. Let's fill it with some sample code (in other words, copy and paste the snippet below):
+
+   .. code-block:: cpp
+
+      #include <cv.h>
+      #include <highgui.h>
+
+      using namespace cv;
+
+      int main( int argc, char** argv )
+      {
+        Mat image;
+        image = imread( argv[1], 1 );
+
+        if( argc != 2 || !image.data )
+          { 
+            printf( "No image data \n" );
+            return -1; 
+          }
+
+        namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
+        imshow( "Display Image", image );
+
+        waitKey(0);
+
+        return 0;
+      }
+
+#. We are only missing one final step: To tell OpenCV where the OpenCV headers and libraries are. For this, do the following:
+
+    * Go to  **Project-->Properties**
+
+    * In **C/C++ Build**, click on **Settings**. At the right, choose the **Tool Settings** Tab. Here we will enter the headers and libraries info:
+
+      a. In **GCC C++ Compiler**, go to **Includes**. In **Include paths(-l)** you should include the path of the folder where opencv was installed. In our example, this is ``/usr/local/include/opencv``.
+
+         .. image:: images/a9.png
+            :alt: Eclipse Tutorial Screenshot 9
+            :align: center
+
+         .. note::
+            If you do not know where your opencv files are, open the **Terminal** and type: 
+
+            .. code-block:: bash
+
+               pkg-config --cflags opencv
+
+            For instance, that command gave me this output:
+
+            .. code-block:: bash
+
+               -I/usr/local/include/opencv -I/usr/local/include 
+
+
+      b. Now go to **GCC C++ Linker**,there you have to fill two spaces:
+
+         First in **Library search path (-L)** you have to write the path to where the opencv libraries reside, in my case the path is:
+         ::
+          
+            /usr/local/lib
+          
+         Then in **Libraries(-l)** add the OpenCV libraries that you may need. Usually just the 3 first on the list below are enough (for simple applications) . In my case, I am putting all of them since I plan to use the whole bunch:
+
+
+         opencv_core      
+         opencv_imgproc     
+         opencv_highgui
+         opencv_ml       
+         opencv_video      
+         opencv_features2d
+         opencv_calib3d   
+         opencv_objdetect   
+         opencv_contrib
+         opencv_legacy    
+         opencv_flann
+
+         .. image:: images/a10.png
+             :alt: Eclipse Tutorial Screenshot 10
+             :align: center 
+             
+         If you don't know where your libraries are (or you are just psychotic and want to make sure the path is fine), type in **Terminal**:
+
+         .. code-block:: bash
+         
+            pkg-config --libs opencv
+
+
+         My output (in case you want to check) was:
+         .. code-block:: bash
+            
+            -L/usr/local/lib -lopencv_core -lopencv_imgproc -lopencv_highgui -lopencv_ml -lopencv_video -lopencv_features2d -lopencv_calib3d -lopencv_objdetect -lopencv_contrib -lopencv_legacy -lopencv_flann  
+
+         Now you are done. Click **OK**
+
+    * Your project should be ready to be built. For this, go to **Project->Build all**   
+
+      In the Console you should get something like 
+
+      .. image:: images/a12.png
+         :alt: Eclipse Tutorial Screenshot 12
+         :align: center 
+
+      If you check in your folder, there should be an executable there.
+
+Running the executable
+========================
+
+So, now we have an executable ready to run. If we were to use the Terminal, we would probably do something like:
+
+.. code-block:: bash
+
+   cd <DisplayImage_directory>
+   cd src
+   ./DisplayImage ../images/HappyLittleFish.png
+
+Assuming that the image to use as the argument would be located in <DisplayImage_directory>/images/HappyLittleFish.png. We can still do this, but let's do it from Eclipse:
+
+
+#. Go to **Run->Run Configurations** 
+
+#. Under C/C++ Application you will see the name of your executable + Debug (if not, click over C/C++ Application a couple of times). Select the name (in this case **DisplayImage Debug**). 
+
+#. Now, in the right side of the window, choose the **Arguments** Tab. Write the path of the image file we want to open (path relative to the workspace/DisplayImage folder). Let's use **HappyLittleFish.png**:
+
+   .. image:: images/a14.png
+      :alt: Eclipse Tutorial Screenshot 14
+      :align: center 
+
+#. Click on the **Apply** button and then in Run. An OpenCV window should pop up with the fish image (or whatever you used).
+
+   .. image:: images/a15.jpg
+      :alt: Eclipse Tutorial Screenshot 15
+      :align: center 
+
+#. Congratulations! You are ready to have fun with OpenCV using Eclipse.
+
+==================================================
+V2: Using CMake+OpenCV with Eclipse (plugin CDT)
+==================================================
+
+(See the `getting started <http://opencv.willowgarage.com/wiki/Getting_started>` section of the OpenCV Wiki)
+
+Say you have or create a new file, *helloworld.cpp* in a directory called *foo*:
+
+.. code-block:: cpp
+
+
+   #include <cv.h>
+   #include <highgui.h>
+   int main ( int argc, char **argv )
+   {
+     cvNamedWindow( "My Window", 1 );
+     IplImage *img = cvCreateImage( cvSize( 640, 480 ), IPL_DEPTH_8U, 1 );
+     CvFont font;
+     double hScale = 1.0;
+     double vScale = 1.0;
+     int lineWidth = 1;
+     cvInitFont( &font, CV_FONT_HERSHEY_SIMPLEX | CV_FONT_ITALIC,
+                 hScale, vScale, 0, lineWidth );
+     cvPutText( img, "Hello World!", cvPoint( 200, 400 ), &font,
+                cvScalar( 255, 255, 0 ) );
+     cvShowImage( "My Window", img );
+     cvWaitKey();
+     return 0;
+   }
+
+1. Create a build directory, say, under *foo*: ``mkdir /build``.  Then ``cd build``.
+
+#. Put a *CmakeLists.txt* file in build:
+
+.. code-block:: bash
+
+   PROJECT( helloworld_proj )
+   FIND_PACKAGE( OpenCV REQUIRED )
+   ADD_EXECUTABLE( helloworld helloworld.cxx )
+   TARGET_LINK_LIBRARIES( helloworld ${OpenCV_LIBS} )
+
+#. Run: ``cmake-gui ..`` and make sure you fill in where opencv was built. 
+
+#. Then click ``configure`` and then ``generate``. If it's OK, **quit cmake-gui**
+
+#. Run ``make -j4``   *(the ``-j4`` is optional, it just tells the compiler to build in 4 threads)*. Make sure it builds.
+
+#. Start ``eclipse`` . Put the workspace in some directory but **not** in ``foo`` or ``foo\\build``
+
+#. Right click in the ``Project Explorer`` section. Select ``Import``  And then open the ``C/C++`` filter. Choose *Existing Code* as a Makefile Project``
+
+#. Name your project, say *helloworld*. Browse to the Existing Code location ``foo\\build`` (where you ran your cmake-gui from). Select *Linux GCC* in the *"Toolchain for Indexer Settings"* and press *Finish*.
+
+#. Right click in the ``Project Explorer`` section. Select ``Properties``. Under ``C/C++ Build``, set the *build directory:* from something like ``${workspace_loc:/helloworld}`` to ``${workspace_loc:/helloworld}/build`` since that's where you are building to.
+
+ a. You can also optionally modify the ``Build command:`` from ``make`` to something like ``make VERBOSE=1 -j4`` which tells the compiler to produce detailed symbol files for debugging and also to compile in 4 parallel threads.
+
+#. Done!
+
+
+
diff --git a/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.jpg b/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.jpg
new file mode 100644
index 0000000000..9eeef5ddb4
Binary files /dev/null and b/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.jpg differ
diff --git a/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.png b/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.png
deleted file mode 100644
index 524f7e2143..0000000000
Binary files a/doc/tutorials/introduction/linux_gcc_cmake/images/GCC_CMake_Example_Tutorial.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_gcc_cmake/images/gccegg-65.png b/doc/tutorials/introduction/linux_gcc_cmake/images/gccegg-65.png
deleted file mode 100644
index cd59029373..0000000000
Binary files a/doc/tutorials/introduction/linux_gcc_cmake/images/gccegg-65.png and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_gcc_cmake/linux_gcc_cmake.rst b/doc/tutorials/introduction/linux_gcc_cmake/linux_gcc_cmake.rst
index 7b9d5ed3c7..d5e039134a 100644
--- a/doc/tutorials/introduction/linux_gcc_cmake/linux_gcc_cmake.rst
+++ b/doc/tutorials/introduction/linux_gcc_cmake/linux_gcc_cmake.rst
@@ -78,7 +78,6 @@ By now you should have an executable (called DisplayImage in this case). You jus
 
 You should get a nice window as the one shown below:
 
-.. image:: images/GCC_CMake_Example_Tutorial.png
+.. image:: images/GCC_CMake_Example_Tutorial.jpg
    :alt: Display Image - Lena
    :align: center
-
diff --git a/doc/tutorials/introduction/linux_install/images/ubuntu_logo.jpeg b/doc/tutorials/introduction/linux_install/images/ubuntu_logo.jpeg
deleted file mode 100644
index 50544c119c..0000000000
Binary files a/doc/tutorials/introduction/linux_install/images/ubuntu_logo.jpeg and /dev/null differ
diff --git a/doc/tutorials/introduction/linux_install/linux_install.rst b/doc/tutorials/introduction/linux_install/linux_install.rst
index 52f080addd..e78e1d849c 100644
--- a/doc/tutorials/introduction/linux_install/linux_install.rst
+++ b/doc/tutorials/introduction/linux_install/linux_install.rst
@@ -19,7 +19,7 @@ Required packages
   * pkgconfig
   * libpng, zlib, libjpeg, libtiff, libjasper with development files (e.g. libpjeg-dev)
   * Python 2.3 or later with developer packages (e.g. python-dev)
-  * SWIG 1.3.30 or later
+  * SWIG 1.3.30 or later (only for versions prior to OpenCV 2.3)
   * libavcodec
   * libdc1394 2.x 
 
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.jpg b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.jpg
new file mode 100644
index 0000000000..fcc7afa4e3
Binary files /dev/null and b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.jpg differ
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.png b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.png
deleted file mode 100644
index 91c9eb6b76..0000000000
Binary files a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_1.png and /dev/null differ
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.jpg b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.jpg
new file mode 100644
index 0000000000..e91b6a1a02
Binary files /dev/null and b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.jpg differ
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.png b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.png
deleted file mode 100644
index ccf4f493fc..0000000000
Binary files a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_2.png and /dev/null differ
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_a.png b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_a.png
deleted file mode 100644
index c4b76850c3..0000000000
Binary files a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_a.png and /dev/null differ
diff --git a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_b.png b/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_b.png
deleted file mode 100644
index cc31604c61..0000000000
Binary files a/doc/tutorials/introduction/load_save_image/images/Load_Save_Image_Result_b.png and /dev/null differ
diff --git a/doc/tutorials/introduction/load_save_image/load_save_image.rst b/doc/tutorials/introduction/load_save_image/load_save_image.rst
index 8afdf0c2d4..6ea6499982 100644
--- a/doc/tutorials/introduction/load_save_image/load_save_image.rst
+++ b/doc/tutorials/introduction/load_save_image/load_save_image.rst
@@ -1,22 +1,22 @@
 .. _Load_Save_Image:
 
-Load and Save an Image
-***********************
+Load, Modify, and Save an Image
+*******************************
 
 .. note::
 
-   We assume that by now you know:
-
-   * Load an image using :imread:`imread <>`
-   * Display an image in an OpenCV window (using :imshow:`imshow <>`)
+   We assume that by now you know how to load an image using :imread:`imread <>` and to display it in a window (using :imshow:`imshow <>`). Read the :ref:`Display_Image` tutorial otherwise. 
  
 Goals
 ======
 
 In this tutorial you will learn how to:
 
-* Transform an image from RGB to Grayscale format by using :cvt_color:`cvtColor <>`
-* Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)
+.. container:: enumeratevisibleitemswithsquare
+
+   * Load an image using :imread:`imread <>`
+   * Transform an image from RGB to Grayscale format by using :cvt_color:`cvtColor <>`
+   * Save your transformed image in a file on disk (using :imwrite:`imwrite <>`)
 
 Code
 ======
@@ -47,7 +47,7 @@ Here it is:
     Mat gray_image;
     cvtColor( image, gray_image, CV_RGB2GRAY );
 
-    imwrite( "../../images/Gray_Image.png", gray_image );
+    imwrite( "../../images/Gray_Image.jpg", gray_image );
 
     namedWindow( imageName, CV_WINDOW_AUTOSIZE );
     namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
@@ -76,20 +76,21 @@ Explanation
 
    As you can see, :cvt_color:`cvtColor <>` takes as arguments:
 
-   * a source image (*image*) 
-   * a destination image (*gray_image*), in which we will save the converted image.
+   .. container:: enumeratevisibleitemswithsquare
 
-   And an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_RGB2GRAY** (self-explanatory).
+      * 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_RGB2GRAY** (self-explanatory).
 
 #. 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 :imread:`imread <>`: :imwrite:`imwrite <>`
 
    .. code-block:: cpp
 
-      imwrite( "../../images/Gray_Image.png", gray_image );   
+      imwrite( "../../images/Gray_Image.jpg", gray_image );   
 
-   Which will save our *gray_image* as *Gray_Image.png* in the folder *images* located two levels up of my current location.
+   Which will save our *gray_image* as *Gray_Image.jpg* in the folder *images* located two levels up of my current location.
 
-#. Finally, let's check out the images. We create 02 windows and use them to show the original image as well as the new one:
+#. Finally, let's check out the images. We create two windows and use them to show the original image as well as the new one:
 
    .. code-block:: cpp
 
@@ -99,7 +100,7 @@ Explanation
       imshow( imageName, image );
       imshow( "Gray image", gray_image );
 
-#. Add the usual *waitKey(0)* for the program to wait forever until the user presses a key.
+#. Add add the *waitKey(0)* function call for the program to wait forever for an user key press.
 
 
 Result
@@ -107,16 +108,14 @@ Result
 
 When you run your program you should get something like this:
 
- .. image:: images/Load_Save_Image_Result_1.png
+ .. image:: images/Load_Save_Image_Result_1.jpg
     :alt: Load Save Image Result 1
-    :height: 400px
     :align: center
 
-And if you check in your folder (in my case *images*), you should have a newly .png file named *Gray_Image.png*:
+And if you check in your folder (in my case *images*), you should have a newly .jpg file named *Gray_Image.jpg*:
 
- .. image:: images/Load_Save_Image_Result_2.png
+ .. image:: images/Load_Save_Image_Result_2.jpg
     :alt: Load Save Image Result 2
-    :height: 250px
     :align: center
 
-Congratulations, you are done with this tutorial! 
+Congratulations, you are done with this tutorial!
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.jpg
new file mode 100644
index 0000000000..9c646e21ae
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.png b/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.png
deleted file mode 100644
index 0c2e67c1dc..0000000000
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/Display_Image_Tutorial_Result.png and /dev/null differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.jpg
new file mode 100644
index 0000000000..5b8fc982ce
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.png b/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.png
deleted file mode 100644
index 97fef256d9..0000000000
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/Load_Save_Image_Result_1.png and /dev/null differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/android_logo.png b/doc/tutorials/introduction/table_of_content_introduction/images/android_logo.png
new file mode 100644
index 0000000000..69bccd74d2
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/android_logo.png differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/eclipse_cpp_logo.jpeg b/doc/tutorials/introduction/table_of_content_introduction/images/eclipse_cpp_logo.jpeg
index 95d4b7938d..e63e26b1b4 100644
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/eclipse_cpp_logo.jpeg and b/doc/tutorials/introduction/table_of_content_introduction/images/eclipse_cpp_logo.jpeg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.jpg
new file mode 100644
index 0000000000..e3e44d1f6c
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.png b/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.png
deleted file mode 100644
index cd59029373..0000000000
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/gccegg-65.png and /dev/null differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu-logo.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu-logo.jpg
new file mode 100644
index 0000000000..a34243496c
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu-logo.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu_logo.jpeg b/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu_logo.jpeg
deleted file mode 100644
index 0efc4f73d7..0000000000
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/ubuntu_logo.jpeg and /dev/null differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/visual-studio-2010-logo.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/visual-studio-2010-logo.jpg
new file mode 100644
index 0000000000..8b053695c4
Binary files /dev/null and b/doc/tutorials/introduction/table_of_content_introduction/images/visual-studio-2010-logo.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/images/windows_logo.jpg b/doc/tutorials/introduction/table_of_content_introduction/images/windows_logo.jpg
index 9727ee4e90..e35a8a86ae 100644
Binary files a/doc/tutorials/introduction/table_of_content_introduction/images/windows_logo.jpg and b/doc/tutorials/introduction/table_of_content_introduction/images/windows_logo.jpg differ
diff --git a/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst b/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst
index 2b8884fd1c..7b41cf876e 100644
--- a/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst
+++ b/doc/tutorials/introduction/table_of_content_introduction/table_of_content_introduction.rst
@@ -5,127 +5,192 @@ Introduction to OpenCV
 
 Here you can read tutorials about how to set up your computer to work with the OpenCV library. Additionaly you can find a few very basic sample source code that will let introduce you to the world of the OpenCV.
 
+.. include:: ../../definitions/tocDefinitions.rst
+
+* **Linux**
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  =========== ======================================================
+  |Install_1| **Title:** :ref:`Linux-Installation`
+
+              *Compatibility:* > OpenCV 2.0
+
+              *Author:* |Author_AnaH|
+
+              We will learn how to setup OpenCV in your computer!
+
+  =========== ======================================================
+
+  .. |Install_1| image:: images/ubuntu-logo.jpg
+                 :height: 90pt
+                 :width:  90pt
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  =========== ======================================================
+   |Usage_1|  **Title:** :ref:`Linux_GCC_Usage`
+
+              *Compatibility:* > OpenCV 2.0
+
+              *Author:* |Author_AnaH|
+
+              We will learn how to compile your first project using gcc and CMake
+
+  =========== ======================================================
+
+  .. |Usage_1| image:: images/gccegg-65.jpg
+               :height: 90pt
+               :width:  90pt
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  =========== ======================================================
+   |Usage_2|  **Title:** :ref:`Linux_Eclipse_Usage`
+
+              *Compatibility:* > OpenCV 2.0
+
+              *Author:* |Author_AnaH|
+
+              We will learn how to compile your first project using the Eclipse environment
+
+  =========== ======================================================
+
+     .. |Usage_2| image:: images/eclipse_cpp_logo.jpeg
+                    :height: 90pt
+                    :width:  90pt
+
+* **Windows**
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+    
+  =========== ======================================================
+  |WinInstal| **Title:** :ref:`Windows_Installation`
+
+              *Compatibility:* > OpenCV 2.0
+
+              *Author:* |Author_BernatG|
+
+              You will learn how to setup OpenCV in your Windows Operating System!
+
+  =========== ======================================================
+
+  .. |WinInstal| image:: images/windows_logo.jpg
+                 :height: 90pt
+                 :width:  90pt
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+  
+  =========== ======================================================
+  |WinVSHowT| **Title:** :ref:`Windows_Visual_Studio_How_To`
+
+              *Compatibility:* > OpenCV 2.0
+
+              *Author:* |Author_BernatG|
+
+              You will learn what steps you need to perform in order to use the OpenCV library inside a new Microsoft Visual Studio project. 
+
+  =========== ======================================================
+
+     .. |WinVSHowT| image:: images/visual-studio-2010-logo.jpg
+                      :height: 90pt
+                      :width:  90pt
+
+* **Android**
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+    
+  ================ ======================================================
+  |AndroidBinPack| **Title:** :ref:`Android_Binary_Package`
+
+                   *Compatibility:* > OpenCV 2.3.1
+
+                   *Author:* |Author_AndreyK|
+
+                   You will learn how to setup OpenCV for Android platform!
+
+  ================ ======================================================
+
+     .. |AndroidBinPack| image:: images/android_logo.png
+                           :height: 90pt
+                           :width:  90pt
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+    
+  ================ ======================================================
+  |AndroidNDKPack| **Title:** :ref:`Android_Binary_Package_with_NDK`
+
+                   *Compatibility:* > OpenCV 2.3.1
+
+                   *Author:* |Author_LeonidBLB|
+
+                   You will learn how to work with C++ OpenCV code for Android platform
+
+  ================ ======================================================
+
+     .. |AndroidNDKPack| image:: images/android_logo.png
+                           :height: 90pt
+                           :width:  90pt
+
+* **From where to start?**
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv  
+
+  ============= ======================================================
+  |Beginners_1| **Title:** :ref:`Display_Image`
+
+                *Compatibility:* > OpenCV 2.0
+
+                *Author:* |Author_AnaH|
+
+                We will learn how to display an image using OpenCV
+
+  ============= ======================================================
+
+  .. |Beginners_1| image:: images/Display_Image_Tutorial_Result.jpg
+                   :height: 90pt
+                   :width:  90pt
+
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv  
+  
+  =============== ======================================================
+   |Beginners_2|  **Title:** :ref:`Load_Save_Image`
+
+                  *Compatibility:* > OpenCV 2.0 
+
+                  *Author:* |Author_AnaH| 
+
+                  We will learn how to save an Image in OpenCV...plus a small conversion to grayscale
+
+  =============== ======================================================
+
+  .. |Beginners_2| image:: images/Load_Save_Image_Result_1.jpg
+                   :height: 90pt
+                   :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
 .. We use a custom table of content format and as the table of content only imforms Sphinx about the hierarchy of the files, no need to show it.
 .. toctree::
    :hidden:                
-   
+
    ../linux_install/linux_install
    ../linux_gcc_cmake/linux_gcc_cmake
    ../linux_eclipse/linux_eclipse
    ../windows_install/windows_install
+   ../windows_visual_studio_Opencv/windows_visual_studio_Opencv
+   ../android_binary_package/android_binary_package
+   ../android_binary_package/android_binary_package_using_with_NDK
    ../display_image/display_image
    ../load_save_image/load_save_image
-
-.. |Author_AnaH| unicode:: Ana U+0020 Huam U+00E1 n
-.. |Author_BernatG| unicode:: Bern U+00E1 t U+0020 G U+00E1 bor
-   
-* **Linux**
-
-  * :ref:`Linux-Installation`
-
-     =========== ======================================================
-     |Install_1| *Title:* **Installation steps in Linux**
-
-                 *Compatibility:* > OpenCV 2.0
-                 
-                 *Author:* |Author_AnaH|
-
-                 We will learn how to setup OpenCV in your computer!
-    
-     =========== ======================================================
-    
-     .. |Install_1| image:: images/ubuntu_logo.jpeg
-                    :height: 100pt
-                    :width:  100pt
-
-
-  * :ref:`Linux_GCC_Usage`
-
-     =========== ======================================================
-      |Usage_1|  *Title:* **Using OpenCV with gcc (and CMake)**
-
-                 *Compatibility:* > OpenCV 2.0
-                 
-                 *Author:* |Author_AnaH|
-
-                 We will learn how to compile your first project using gcc and CMake
-    
-     =========== ======================================================
-    
-     .. |Usage_1| image:: images/gccegg-65.png
-                    :height: 100pt
-                    :width:  100pt
-
-
-  * :ref:`Linux_Eclipse_Usage`
-
-     =========== ======================================================
-      |Usage_2|  *Title:* **Using OpenCV with Eclipse (CDT plugin)**
-
-                 *Compatibility:* > OpenCV 2.0
-                 
-                 *Author:* |Author_AnaH|
-
-                 We will learn how to compile your first project using the Eclipse environment
-    
-     =========== ======================================================
-    
-     .. |Usage_2| image:: images/eclipse_cpp_logo.jpeg
-                    :height: 100pt
-                    :width:  100pt
-
-* **Windows**
-
-  * :ref:`Windows_Installation`
-  
-     =========== ======================================================
-     |Install_2| *Title:* **Installation steps in Windows**
-
-                 *Compatibility:* > OpenCV 2.0
-                 
-                 *Author:* |Author_BernatG|
-
-                 You will learn how to setup OpenCV in your Windows Operating System!
-
-     =========== ======================================================
-
-     .. |Install_2| image:: images/windows_logo.jpg
-                    :height: 100pt
-                    :width:  100pt
-
-* **From where to start?**
-
-  * :ref:`Display_Image`
-
-     =============== ======================================================
-      |Beginners_1|  *Title:* **Display an Image**
-
-                     *Compatibility:* > OpenCV 2.0
-                     
-                     *Author:* |Author_AnaH|
-
-                     We will learn how to display an image using OpenCV
-    
-     =============== ======================================================
-    
-     .. |Beginners_1| image:: images/Display_Image_Tutorial_Result.png
-                      :height: 100pt
-                      :width:  100pt
-
-
-  * :ref:`Load_Save_Image`
-
-     =============== ======================================================
-      |Beginners_2|  *Title:* **Load and save an Image**
-
-                     *Compatibility:* > OpenCV 2.0
-                     
-                     *Author:* |Author_AnaH|
-
-                     We will learn how to save an Image in OpenCV...plus a small conversion to grayscale
-    
-     =============== ======================================================
-    
-     .. |Beginners_2| image:: images/Load_Save_Image_Result_1.png
-                      :height: 100pt
-                      :width:  100pt
diff --git a/doc/tutorials/introduction/windows_install/images/CMakeBuildOptionsOpenCV.jpg b/doc/tutorials/introduction/windows_install/images/CMakeBuildOptionsOpenCV.jpg
new file mode 100644
index 0000000000..8a25b70629
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMakeBuildOptionsOpenCV.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/CMakeBuildWithWindowsGUI.jpg b/doc/tutorials/introduction/windows_install/images/CMakeBuildWithWindowsGUI.jpg
new file mode 100644
index 0000000000..eb39491387
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMakeBuildWithWindowsGUI.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/CMakeOutputPackageNotFound.jpg b/doc/tutorials/introduction/windows_install/images/CMakeOutputPackageNotFound.jpg
new file mode 100644
index 0000000000..227f4766df
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMakeOutputPackageNotFound.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/CMakePackageNotFoundWindows.jpg b/doc/tutorials/introduction/windows_install/images/CMakePackageNotFoundWindows.jpg
new file mode 100644
index 0000000000..5cfa668176
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMakePackageNotFoundWindows.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/CMakeSelectBin.jpg b/doc/tutorials/introduction/windows_install/images/CMakeSelectBin.jpg
new file mode 100644
index 0000000000..db37cf65f5
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMakeSelectBin.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/CMake_Configure_Windows.jpg b/doc/tutorials/introduction/windows_install/images/CMake_Configure_Windows.jpg
new file mode 100644
index 0000000000..fb6c506d58
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/CMake_Configure_Windows.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/ChangeBuildVisualStudio.jpg b/doc/tutorials/introduction/windows_install/images/ChangeBuildVisualStudio.jpg
new file mode 100644
index 0000000000..0bba04b5ea
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/ChangeBuildVisualStudio.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/IntelTBB.png b/doc/tutorials/introduction/windows_install/images/IntelTBB.png
new file mode 100644
index 0000000000..64b53b7f31
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/IntelTBB.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/MiktexInstall.png b/doc/tutorials/introduction/windows_install/images/MiktexInstall.png
new file mode 100644
index 0000000000..193a403991
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/MiktexInstall.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/OpenCVBuildResultWindows.jpg b/doc/tutorials/introduction/windows_install/images/OpenCVBuildResultWindows.jpg
new file mode 100644
index 0000000000..4ca9f58e60
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/OpenCVBuildResultWindows.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/OpenCV_Install_Directory.png b/doc/tutorials/introduction/windows_install/images/OpenCV_Install_Directory.png
new file mode 100644
index 0000000000..b038b26b56
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/OpenCV_Install_Directory.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVInsertNew.png b/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVInsertNew.png
new file mode 100644
index 0000000000..9e2f12399b
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVInsertNew.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVSetPath.png b/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVSetPath.png
new file mode 100644
index 0000000000..c9f8987222
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/PathEditorOpenCVSetPath.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/SVNCheckOutProgress.png b/doc/tutorials/introduction/windows_install/images/SVNCheckOutProgress.png
new file mode 100644
index 0000000000..9370b4e807
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/SVNCheckOutProgress.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/Sphinx_Install.png b/doc/tutorials/introduction/windows_install/images/Sphinx_Install.png
new file mode 100644
index 0000000000..da2e06c0bf
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/Sphinx_Install.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckout.png b/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckout.png
new file mode 100644
index 0000000000..8ab3fa1dca
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckout.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckoutWindow.png b/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckoutWindow.png
new file mode 100644
index 0000000000..1bef3ba592
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/TortoiseSVNCheckoutWindow.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/WindowsBuildDoc.png b/doc/tutorials/introduction/windows_install/images/WindowsBuildDoc.png
new file mode 100644
index 0000000000..18cad032c3
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/WindowsBuildDoc.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/WindowsBuildInstall.png b/doc/tutorials/introduction/windows_install/images/WindowsBuildInstall.png
new file mode 100644
index 0000000000..efc1779fc5
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/WindowsBuildInstall.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/WindowsOpenCVDirPath.png b/doc/tutorials/introduction/windows_install/images/WindowsOpenCVDirPath.png
new file mode 100644
index 0000000000..6f98134074
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/WindowsOpenCVDirPath.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/WindowsOpenCVInstaller.png b/doc/tutorials/introduction/windows_install/images/WindowsOpenCVInstaller.png
new file mode 100644
index 0000000000..664a15e62e
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/WindowsOpenCVInstaller.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/WindowsQtContoursOutput.png b/doc/tutorials/introduction/windows_install/images/WindowsQtContoursOutput.png
new file mode 100644
index 0000000000..ebb41ac4b9
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/WindowsQtContoursOutput.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/cmsdstartwindows.jpg b/doc/tutorials/introduction/windows_install/images/cmsdstartwindows.jpg
new file mode 100644
index 0000000000..e0d9530d5c
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/cmsdstartwindows.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/qtDownloadThisPackage.png b/doc/tutorials/introduction/windows_install/images/qtDownloadThisPackage.png
new file mode 100644
index 0000000000..1ed849a6e8
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/qtDownloadThisPackage.png differ
diff --git a/doc/tutorials/introduction/windows_install/images/visualstudiocommandprompt.jpg b/doc/tutorials/introduction/windows_install/images/visualstudiocommandprompt.jpg
new file mode 100644
index 0000000000..712d58b963
Binary files /dev/null and b/doc/tutorials/introduction/windows_install/images/visualstudiocommandprompt.jpg differ
diff --git a/doc/tutorials/introduction/windows_install/images/windows_logo.jpg b/doc/tutorials/introduction/windows_install/images/windows_logo.jpg
deleted file mode 100644
index 37e130dee6..0000000000
Binary files a/doc/tutorials/introduction/windows_install/images/windows_logo.jpg and /dev/null differ
diff --git a/doc/tutorials/introduction/windows_install/windows_install.rst b/doc/tutorials/introduction/windows_install/windows_install.rst
index 7fff23c7aa..720249d46f 100644
--- a/doc/tutorials/introduction/windows_install/windows_install.rst
+++ b/doc/tutorials/introduction/windows_install/windows_install.rst
@@ -1,5 +1,372 @@
-.. _Windows_Installation:
-
-Installation in Windows
-***********************
-For now this is just a stub article. It will be updated with valuable content as soon as possible. Make sure to check back for it!
+.. _Windows_Installation:
+
+Installation in Windows
+***********************
+
+.. include:: <isonum.txt>
+
+The description here was tested by the author using the Windows 7 SP1 **o**\ perating **s**\ ystem (*OS*). Nevertheless, it should also work on any other Windows OS too. If you encounter errors after following the steps described here feel free to contact us via our :opencv_group:`user group <>` and we will try to fix your problem.
+
+.. note:: To use the OpenCV library you have two options: :ref:`Windows_Install_Prebuild` or :ref:`CppTutWindowsMakeOwn`. While the first one is easier to complete, it only works if you are coding inside the latest Microsoft Visual Studio  **i**\ ntegrated **d**\ evelopment **e**\ nvironments (*IDE*) and doesn't takes advantage of the most novel technologies we integrate into our library. 
+
+.. _Windows_Install_Prebuild: 
+
+Installation by using the pre-built libraries
+=============================================
+
+1. Open up a web browser and go to: http://sourceforge.net/projects/opencvlibrary/files/opencv-win/
+
+#. Open the folder for the latest version (currently this is 2.3).
+
+#. Choose a build you want to use and download it. The naming conventions used will show what kind of support they offer. For example:
+   
+   .. container:: enumeratevisibleitemswithsquare
+   
+      * *vs2010* means the Visual Studio 
+      * *win32* means that it is for 32 bit applications in the OS
+      * *gpu* means that it includes the support for using your GPU in order to further increase the performance of the library).
+   
+   If you downloaded the source files present here see :ref:`CppTutWindowsMakeOwn`.
+
+#. Make sure you have admin rights. Start the setup and follow the wizard. Agree to the \" License Agreement \" . 
+
+#. While adding the OpenCV library to the system path is a good decision for a better control of this we will do it manually. Therefore, make sure you do not set this option. 
+
+#. Most of the time it is a good idea to install the source files as this will allow for you to debug into the OpenCV library, if it is necessary. Therefore, just follow the default settings of the wizard and finish the installation. 
+
+#. You can check the installation at the chosen path as you can see below. 
+
+   .. image:: images/OpenCV_Install_Directory.png
+      :alt: An example of how the installation directory should look in case of success.
+      :align: center
+
+#. To finalize the installation go to the :ref:`WindowsSetPathAndEnviromentVariable` section. 
+
+.. _CppTutWindowsMakeOwn: 
+
+Installation by making your own libraries from the source files
+===============================================================
+
+You may find the content of this tutorial also inside the following videos: `Part 1 <https://www.youtube.com/watch?v=NnovZ1cTlMs>`_ and `Part 2 <https://www.youtube.com/watch?v=qGNWMcfWwPU>`_, hosted on YouTube. 
+
+.. raw:: html
+
+  <div align="center">
+  <iframe title="Install OpenCV by using its source files - Part 1" width="560" height="349" src="http://www.youtube.com/embed/NnovZ1cTlMs?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  <iframe title="Install OpenCV by using its source files - Part 2" width="560" height="349" src="http://www.youtube.com/embed/qGNWMcfWwPU?rel=0&loop=1" frameborder="0" allowfullscreen align="middle"></iframe>
+  </div>
+
+If you are building your own libraries you can take either the source files from our latest:
+
+   .. container:: enumeratevisibleitemswithsquare
+
+      + stable and tested build - https://code.ros.org/svn/opencv/branches/2.3 (this will change with every new realease)
+      + development build - https://code.ros.org/svn/opencv/trunk/
+
+While the later one may contain a couple of new and experimental algorithms, performance increases and interface improvements, be aware, that it may also contain many-many bugs. Using the first one is recommended in most of the cases. That is unless you are extending the OpenCV library itself or really need to most up to date version of it. 
+
+Building the OpenCV library from scratch requires a couple of tools installed beforehand:
+
+.. |CMake| replace:: CMake
+.. _CMake: http://www.cmake.org/cmake/resources/software.html
+.. |TortoiseSVN| replace:: TortoiseSVN
+.. _TortoiseSVN: http://tortoisesvn.net/downloads.html
+.. |Python_Libraries| replace:: Python libraries
+.. _Python_Libraries: http://www.python.org/getit/
+.. |Numpy| replace:: Numpy
+.. _Numpy: http://numpy.scipy.org/
+.. |IntelTBB| replace:: Intel |copy| Threading Building Blocks (*TBB*)
+.. _IntelTBB: http://threadingbuildingblocks.org/file.php?fid=77
+.. |IntelIIP| replace:: Intel |copy| Integrated Performance Primitives (*IPP*)
+.. _IntelIIP: http://software.intel.com/en-us/articles/intel-ipp/
+.. |qtframework| replace:: Qt framework 
+.. _qtframework: http://qt.nokia.com/downloads
+.. |Eigen| replace:: Eigen
+.. _Eigen: http://eigen.tuxfamily.org/index.php?title=Main_Page#Download
+.. |CUDA_Toolkit| replace:: CUDA Toolkit
+.. _CUDA_Toolkit: http://developer.nvidia.com/cuda-downloads
+.. |OpenEXR| replace:: OpenEXR
+.. _OpenEXR: http://www.openexr.com/downloads.html
+.. |OpenNI_Framework| replace:: OpenNI Framework
+.. _OpenNI_Framework: http://www.openni.org/
+.. |Miktex| replace:: Miktex
+.. _Miktex: http://miktex.org/2.9/setup
+.. |Sphinx| replace:: Sphinx
+.. _Sphinx: http://sphinx.pocoo.org/
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + An **I**\ ntegrated **D**\ eveloper **E**\ nviroment (*IDE*) preferably, or just a C\C++ compiler that will actually make the binary files. Here I will use the `Microsoft Visual Studio <https://www.microsoft.com/visualstudio/en-us>`_. Nevertheless, you can use any other *IDE* that has a valid C\\C++ compiler. 
+      
+   + Then |CMake|_ is a neat tool that will make the project files (for your choosen *IDE*) from the OpenCV source files. It will also allow an easy configuration of the OpenCV build files, in order to make binary files that fits exactly to your needs. 
+   
+   + A **S**\ ubversion **C**\ ontrol **S**\ ystem (*SVN*) to acquire the OpenCV source files. A good tool for this is |TortoiseSVN|_. Alternatively, you can just download an archived version of the source files from the `Sourceforge OpenCV page <http://sourceforge.net/projects/opencvlibrary/files/opencv-win/>`_.
+
+OpenCV may come in multiple flavors. There is a "core" section that will work on its own. Nevertheless, they are a couple of tools, libraries made by other organizations (so called 3rd parties) that offer services of which the OpenCV may take advantage. These will improve in many ways its capabilities. In order to use any of them, you need to download and install them on your system. 
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + The |Python_Libraries|_ are required to build the *Python interface* of OpenCV. For now use the version :file:`2.7.{x}`. This is also a must have if you want to build the *OpenCV documentation*.
+
+   + |Numpy|_ is a scientific computing package for Python. Required for the *Python interface*. 
+
+   + |IntelTBB|_ is used inside OpenCV for parallel code snippets. Using this will make sure that the OpenCV library will take advantage of all the cores you have in your systems CPU. 
+
+   + |IntelIIP|_ may be used to improve the performance of color conversion, Haar training and DFT functions of the OpenCV library. Watch out as this isn't a *free* service. 
+
+   + OpenCV offers a somewhat fancier and more useful graphical user interface, than the default one by using the |qtframework|_. For a quick overview of what this has to offer look into the documentations *highgui* module, under the *Qt New Functions* section. Version 4.6 or later of the framework is required. 
+
+   + |Eigen|_ is a C++ template library for linear algebra. 
+
+   + The latest |CUDA_Toolkit|_ will allow you to use the power lying inside your GPU.  This will drastically improve performance for some of the algorithms, like the HOG descriptor. Getting to work more and more of our algorithms on the GPUs is a constant effort of the OpenCV team. 
+
+   + |OpenEXR|_ source files are required for the library to work with this high dynamic range (HDR) image file format. 
+
+   + The |OpenNI_Framework|_ contains a set of open source APIs that provide support for natural interaction with devices via methods such as voice command recognition, hand gestures and body motion tracking. 
+
+   + |Miktex|_ is the best `TEX <https://secure.wikimedia.org/wikipedia/en/wiki/TeX>`_ implementation on the Windows OS. It is required to build the *OpenCV documentation*. 
+
+   + |Sphinx|_ is a python documentation generator and is the tool that will actually create the *OpenCV documentation*. This on its own requires a couple of tools installed, I will cover this in depth at the :ref:`How to Install Sphinx <HereInstallSphinx>` section. 
+
+Now I will describe the steps to follow for a full build (using all the above frameworks, tools and libraries). If you do not need the support for some of these you can just freely skip those parts. 
+
+.. _WindowsBuildLibrary:
+
+Building the library
+^^^^^^^^^^^^^^^^^^^^
+
+1. Make sure you have a working IDE with a valid compiler. In case of the Microsoft Visual Studio just install it and make sure it starts up. 
+
+#. Install |CMake|_. Simply follow the wizard, no need to add it to the path. The default install options are great. No need to change them. 
+
+#. Install |TortoiseSVN|_. Choose the 32 or 64 bit version according to the type of OS you work in. Again follow the wizard, default options are good. Restart of your system is required. 
+
+#. Choose a directory in your file system where you will download the OpenCV libraries. I recommend creating a new one that has short path and no special charachters in it, for example :file:`D:/OpenCV`. During this tutorial I'll suppose you've done so. If you use a different directory just change this front part of the path in my future examples. Then, :menuselection:`Right Click --> SVN Checkout...` in the directory. 
+   
+   .. image:: images/TortoiseSVNCheckout.png
+      :alt: The TortoiseSVN Checkout Menu
+      :align: center
+   
+   A window will appear where you can select from what repository you want to download source files (1) and to which directory (2):
+   
+   .. image:: images/TortoiseSVNCheckoutWindow.png
+      :alt: The TortoiseSVN Checkout Window
+      :align: center
+   
+   Add here either ones of the versions described above. Then push the OK button and be patient as the repository currently is over 330MB to download. It will take some time until it is finished depending on your Internet connection. 
+   
+   .. image:: images/SVNCheckOutProgress.png
+      :alt: The TortoiseSVN Checkout Progress
+      :align: center
+   
+   When you are done you should have a *opencv* and an *opencv_extra* directory as seen at (3). 
+
+#. In this section I will cover installing the 3rd party libraries.
+
+   a) Download the |Python_Libraries|_ and install it with the default options. You will need a couple other python extensions. Luckily installing all these may be automated by a nice tool called `Setuptools <http://pypi.python.org/pypi/setuptools#downloads>`_. Download and install again.
+
+   #) .. _HereInstallSphinx: 
+
+      Installing Sphinx is easy once you have installed *Setuptools*. This contains a little application that will automatically connect to the python databases and download the latest version of many python scripts. Start up a command window (enter *cmd* into the windows start menu and press enter) and use the *CD* command to navigate to your Python folders Script sub-folder. Here just pass to the *easy_install.exe* as argument the name of the program you want to install. Add the *sphinx* argument. 
+      
+      .. image:: images/cmsdstartwindows.jpg
+         :alt: The Windows Command Startup
+         :align: center
+      
+      .. image:: images/Sphinx_Install.png
+         :alt: How to start the command window
+         :align: center
+      
+      .. note:: 
+
+         The *CD* navigation command works only inside a drive. For example if you are somewhere in the *C:* drive you cannot use it this to go to another drive (like for example *D:*). To do so you first need to change drives letters. For this simply enter the command *D:*. Then you can use the *CD* to navigate to specific folder inside the drive. Bonus tip: you can clear the screen by using the *CLS* command. 
+
+      This will also install its prerequisites `Jinja2 <http://jinja.pocoo.org/docs/>`_ and `Pygments <http://pygments.org/>`_. 
+
+   #) The easiest way to install |Numpy|_ is to just download its binaries from the `sourceforga page <http://sourceforge.net/projects/numpy/files/NumPy/>`_. Make sure your download and install exactly the binary for your python version (so for version :file:`2.7`).
+
+   #) Download the |Miktex|_ and install it. Again just follow the wizard. At the fourth step make sure you select for the *"Install missing packages on-the-fly"* the *Yes* option, as you can see on the image below. Again this will take quite some time so be patient. 
+      
+      .. image:: images/MiktexInstall.png
+         :alt: The Miktex Install Screen
+         :align: center
+
+   #) For the |IntelTBB|_ download the source files and extract it inside a directory on your system. For example let there be :file:`D:/OpenCV/dep`. For installing the |IntelIIP|_ the story is the same. For exctracting the archives I recommend using the `7-Zip <http://www.7-zip.org/>`_ application. 
+      
+      .. image:: images/IntelTBB.png
+         :alt: The Miktex Install Screen
+         :align: center
+   
+   #) In case of the |Eigen|_ library it is again a case of download and extract to the :file:`D:/OpenCV/dep` directory.
+   
+   #) Same as above with |OpenEXR|_. 
+   
+   #) For the |OpenNI_Framework|_ you need to install both the `development build <http://www.openni.org/downloadfiles/opennimodules/openni-binaries/21-stable>`_ and the `PrimeSensor Module <http://www.openni.org/downloadfiles/opennimodules/openni-compliant-hardware-binaries/32-stable>`_.
+   
+   #) For the CUDA you need again two modules: the latest |CUDA_Toolkit|_ and the *CUDA Tools SDK*. Download and install both of them with a *complete* option by using the 32 or 64 bit setups according to your OS.
+   
+   #) In case of the |qtframework|_ you need to build yourself the binary files (unless you use the Microsoft Visual Studio 2008 with 32 bit compiler). To do this go to the `Qt Downloads <http://qt.nokia.com/downloads>`_ page. Download the source files (not the installers!!!):
+      
+      .. image:: images/qtDownloadThisPackage.png
+         :alt: Download this Qt Package
+         :align: center
+    
+      Extract it into a nice and short named directory like :file:`D:/OpenCV/dep/qt/` . 
+      Then you need to build it. Start up a *Visual* *Studio* *Command* *Prompt* (*2010*) by using the start menu search (or navigate through the start menu :menuselection:`All Programs --> Microsoft Visual Studio 2010 --> Visual Studio Tools --> Visual Studio Command Prompt (2010)`). 
+      
+      .. image:: images/visualstudiocommandprompt.jpg
+         :alt: The Visual Studio command prompt
+         :align: center
+      
+      Now navigate to the extracted folder and enter inside it by using this console window. You should have a folder containing files like *Install*, *Make* and so on. Use the *dir* command to list files inside your current directory. Once arrived at this directory enter the following command: 
+      
+      .. code-block:: bash
+      
+         configure.exe -release -no-webkit -no-phonon -no-phonon-backend -no-script -no-scripttools 
+                       -no-qt3support -no-multimedia -no-ltcg
+      
+      Completing this will take around 10-20 minutes. Then enter the next command that will take a lot longer (can easily take even more than a full hour):
+      
+      .. code-block:: bash
+      
+         nmake
+
+      After this set the Qt enviroment variables using the following command on Windows 7:
+      
+      .. code-block:: bash
+         
+         setx -m QTDIR D:/OpenCV/dep/qt/qt-everywhere-opensource-src-4.7.3
+      
+      .. |PathEditor| replace:: Path Editor
+      .. _PathEditor: http://www.redfernplace.com/software-projects/patheditor/
+      
+      Also, add the built binary files path to the system path by using the  |PathEditor|_. In our case this is :file:`D:/OpenCV/dep/qt/qt-everywhere-opensource-src-4.7.3/bin`. 
+      
+      .. note:: 
+      
+         If you plan on doing Qt application development you can also install at this point the *Qt Visual Studio Add-in*. After this you can make and build Qt applications without using the *Qt Creator*. Everything is nicely integrated into Visual Studio. 
+      
+#. Now start the *CMake (cmake-gui)*. You may again enter it in the start menu search or get it from the :menuselection:`All Programs --> CMake 2.8 --> CMake (cmake-gui)`. First, select the directory for the source files of the OpenCV library (1). Then, specify a directory where you will build the binary files for OpenCV (2). 
+   
+   .. image:: images/CMakeSelectBin.jpg
+      :alt: Select the directories
+      :align: center
+
+   Press the Configure button to specify the compiler (and *IDE*) you want to use. Note that in case you can choose between different compilers for making either 64 bit or 32 bit libraries. Select the one you use in your application development. 
+   
+   .. image:: images/CMake_Configure_Windows.jpg
+      :alt: How CMake should look at build time. 
+      :align: center
+   
+   CMake will start out and based on your system variables will try to automatically locate as many packages as possible. You can modify the packages to use for the build in the :menuselection:`WITH --> WITH_X` menu points (where *X* is the package abbreviation). Here are a list of current packages you can turn on or off: 
+   
+   .. image:: images/CMakeBuildWithWindowsGUI.jpg
+      :alt: The packages OpenCV may use
+      :align: center
+   
+   Select all the packages you want to use and press again the *Configure* button. For an easier overview of the build options make sure the *Grouped* option under the binary directory selection is turned on. For some of the packages CMake may not find all of the required files or directories. In case of these CMake will throw an error in its output window (located at the bottom of the GUI) and set its field values, to not found constants. For example: 
+   
+   .. image:: images/CMakePackageNotFoundWindows.jpg
+      :alt: Constant for not found packages
+      :align: center
+      
+   .. image:: images/CMakeOutputPackageNotFound.jpg
+      :alt: Error (warning) thrown in output window of the CMake GUI
+      :align: center
+   
+   For these you need to manually set the queried directories or files path. After this press again the *Configure* button to see if the value entered by you was accepted or not. Do this until all entries are good and you cannot see errors in the field/value or the output part of the GUI.
+   Now I want to emphasize an option that you will definitely love: :menuselection:`ENABLE --> ENABLE_SOLUTION_FOLDERS`. OpenCV will create many-many projects and turning this option will make sure that they are categorized inside directories in the *Solution Explorer*. It is a must have feature, if you ask me. 
+   
+   .. image:: images/CMakeBuildOptionsOpenCV.jpg
+      :alt: Set the Solution Folders and the parts you want to build
+      :align: center
+      
+   Furthermore, you need to select what part of OpenCV you want to build.
+   
+   .. container:: enumeratevisibleitemswithsquare
+       
+      + *BUILD_DOCS* -> It creates two projects for building the documentation of OpenCV (there will be a separate project for building the HTML and the PDF files). Note that these aren't built together with the solution. You need to make an explicit build project command on these to do so.
+      + *BUILD_EXAMPLES* -> OpenCV comes with many example applications from which you may learn most of the libraries capabilities. This will also come handy to easily try out if OpenCV is fully functional on your computer. 
+      + *BUILD_JAVA_SUPPORT* -> At the moment this has no real meaning on the Windows platform. Ignore it.
+      + *BUILD_NEW_PYTHON_SUPPORT* -> Self-explanatory. Create the binaries to use OpenCV from the Python language. 
+      + *BUILD_PACKAGE* -> Prior to version 2.3 with this you could build a project that will build an OpenCV installer. With this you can easily install your OpenCV flavor on other systems.  For the latest source files of OpenCV it generates a new project that simply creates zip archive with OpenCV sources. 
+      + *BUILD_SHARED_LIBS* -> With this you can control to build DLL files (when turned on) or static library files (\*.lib) otherwise. 
+      + *BUILD_TESTS* -> Each module of OpenCV has a test project assigned to it. Building these test projects is also a good way to try out, that the modules work just as expected on your system too. 
+   
+   Press again the *Configure* button and ensure no errors are reported. If this is the case you can tell CMake to create the project files by pushing the *Generate* button. Go to the build directory and open the created **OpenCV** solution.
+   Depending on just how much of the above options you have selected the solution may contain quite a lot of projects so be tolerant on the IDE at the startup. 
+   Now you need to build both the *Release* and the *Debug* binaries. Use the drop-down menu on your IDE to change to another of these after building for one of them.
+   
+   .. image:: images/ChangeBuildVisualStudio.jpg
+      :alt: Look here for changing the Build Type
+      :align: center
+   
+   In the end you can observe the built binary files inside the bin directory:
+   
+   .. image:: images/OpenCVBuildResultWindows.jpg
+      :alt: The Result of the build. 
+      :align: center
+   
+   For the documentation you need to explicitly issue the build commands on the *doc* project for the PDF files and  on the *doc_html* for the HTML ones. Each of these will call *Sphinx* to do all the hard work. You can find the generated documentation inside the :file:`Build/Doc/_html` for the HTML pages and within the :file:`Build/Doc` the PDF manuals. 
+  
+   .. image:: images/WindowsBuildDoc.png
+      :alt: The Documentation Projects
+      :align: center
+   
+   To collect the header and the binary files, that you will use during your own projects, into a separate directory (simillary to how the pre-built binaries ship) you need to explicitely build the *Install* project. 
+   
+   .. image:: images/WindowsBuildInstall.png
+      :alt: The Install Project
+      :align: center
+   
+   This will create an *install* directory inside the *Build* one collecting all the built binaries into a single place. Use this only after you built both the *Release* and *Debug* versions. 
+   
+   .. note::
+   
+      To create an installer you need to install `NSIS <http://nsis.sourceforge.net/Download>`_. Then just build the *Package* project to build the installer into the :file:`Build/_CPack_Packages/{win32}/NSIS` folder. You can then use this to distribute OpenCV with your build settings on other systems.
+      
+      .. image:: images/WindowsOpenCVInstaller.png
+         :alt: The Installer directory
+         :align: center
+   
+   To test your build just go into the :file:`Build/bin/Debug` or :file:`Build/bin/Release` directory and start a couple of applications like the *contours.exe*. If they run, you are done. Otherwise, something definitely went awfully wrong. In this case you should contact us via our :opencv_group:`user group <>`. 
+   If everything is okay the *contours.exe* output should resemble the following image (if built with Qt support): 
+   
+   .. image:: images/WindowsQtContoursOutput.png
+      :alt: A good output result
+      :align: center
+   
+   .. note::
+
+      If you use the GPU module (CUDA libraries) make sure you also upgrade to the latest drivers of your GPU. Error messages containing invalid entries in (or cannot find) the nvcuda.dll are caused mostly by old video card drivers. For testing the GPU (if built) run the *performance_gpu.exe* sample application.
+
+.. _WindowsSetPathAndEnviromentVariable:
+
+Set the OpenCV enviroment variable and add it to the systems path
+=================================================================
+
+First we set an enviroment variable to make easier our work. This will hold the install directory of our OpenCV library that we use in our projects. Start up a command window and enter:
+
+.. code-block:: bash
+
+   setx -m OPENCV_DIR D:\OpenCV\Build\Install
+
+Here the directory is where you have your OpenCV binaries (*installed* or *built*). Inside this you should have folders like *bin* and *include*. The -m should be added if you wish to make the settings computer wise, instead of user wise. 
+
+If you built static libraries then you are done. Otherwise, you need to add the *bin* folders path to the systems path.This is cause you will use the OpenCV library in form of *\"Dynamic-link libraries\"* (also known as **DLL**). Inside these are stored all the algorithms and information the OpenCV library contains. The operating system will load them only on demand, during runtime. However, to do this he needs to know where they are. The systems **PATH** contains a list of folders where DLLs can be found. Add the OpenCV library path to this and the OS will know where to look if he ever needs the OpenCV binaries. Otherwise, you will need to copy the used DLLs right beside the applications executable file (*exe*) for the OS to find it, which is highly unpleasent if you work on many projects. To do this start up again the |PathEditor|_ and add the following new entry (right click in the application to bring up the menu):
+
+.. code-block:: bash
+
+   %OPENCV_DIR%\bin
+
+.. image:: images/PathEditorOpenCVInsertNew.png
+   :alt: Right click to insert new path manually. 
+   :align: center
+   
+.. image:: images/PathEditorOpenCVSetPath.png
+   :alt: Add the entry. 
+   :align: center
+
+Save it to the registry and you are done. If you ever change the location of your install directories or want to try out your applicaton with a different build all you will need to do is to update the OPENCV_DIR variable via the *setx* command inside a command window. 
+
+Now you can continue reading the tutorials with the :ref:`Windows_Visual_Studio_How_To` section. There you will find out how to use the OpenCV library in your own projects with the help of the Microsoft Visual Studio IDE. 
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/AddNewPropertySheet.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/AddNewPropertySheet.jpg
new file mode 100644
index 0000000000..773d4d0b2a
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/AddNewPropertySheet.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/NewProjectVisualStudio.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/NewProjectVisualStudio.jpg
new file mode 100644
index 0000000000..fb12f8f0f1
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/NewProjectVisualStudio.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCVEditEnviromentVisual.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCVEditEnviromentVisual.jpg
new file mode 100644
index 0000000000..f5e55ab395
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCVEditEnviromentVisual.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCV_Install_Directory.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCV_Install_Directory.jpg
new file mode 100644
index 0000000000..3f32c0f674
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/OpenCV_Install_Directory.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageAddExisting.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageAddExisting.jpg
new file mode 100644
index 0000000000..30c3194f97
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageAddExisting.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageExample.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageExample.jpg
new file mode 100644
index 0000000000..f2f2034adc
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertyPageExample.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetInsideFolder.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetInsideFolder.jpg
new file mode 100644
index 0000000000..a20d59f111
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetInsideFolder.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVInclude.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVInclude.jpg
new file mode 100644
index 0000000000..5826f4dd6c
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVInclude.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLib.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLib.jpg
new file mode 100644
index 0000000000..25c88b3762
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLib.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebug.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebug.jpg
new file mode 100644
index 0000000000..c28841acfa
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebug.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebugSmple.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebugSmple.jpg
new file mode 100644
index 0000000000..7fcbf9d8f0
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesDebugSmple.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesRelease.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesRelease.jpg
new file mode 100644
index 0000000000..dd93d21688
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetOpenCVLibrariesRelease.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetVS2010.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetVS2010.jpg
new file mode 100644
index 0000000000..64446ac422
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/PropertySheetVS2010.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/SuccessVisualStudioWindows.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/SuccessVisualStudioWindows.jpg
new file mode 100644
index 0000000000..d63b5c981d
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/SuccessVisualStudioWindows.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2008.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2008.jpg
new file mode 100644
index 0000000000..7cb6aa9151
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2008.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2010.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2010.jpg
new file mode 100644
index 0000000000..4cf1fcd3d8
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VCDirectories2010.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VisualStudioCommandLineArguments.jpg b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VisualStudioCommandLineArguments.jpg
new file mode 100644
index 0000000000..9d52d98945
Binary files /dev/null and b/doc/tutorials/introduction/windows_visual_studio_Opencv/images/VisualStudioCommandLineArguments.jpg differ
diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst b/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst
new file mode 100644
index 0000000000..67b781c455
--- /dev/null
+++ b/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst
@@ -0,0 +1,180 @@
+.. _Windows_Visual_Studio_How_To:
+
+How to build applications with OpenCV inside the *Microsoft Visual Studio*
+**************************************************************************
+
+Everything I describe here will apply to the C\\C++ interface of OpenCV.
+I start out from the assumption that you have read and completed with success the :ref:`Windows_Installation` tutorial. Therefore, before you go any further make sure you have an OpenCV directory that contains the OpenCV header files plus binaries and you have set the environment variables as :ref:`described here <WindowsSetPathAndEnviromentVariable>`.
+
+.. image:: images/OpenCV_Install_Directory.jpg
+   :alt: You should have a folder looking like this.
+   :align: center
+
+The OpenCV libraries, distributed by us, on the Microsoft Windows operating system are in a **D**\ ynamic **L**\ inked **L**\ ibraries (*DLL*). These have the advantage that all the content of the library are loaded only at runtime, on demand, and that countless programs may use the same library file. This means that if you have ten applications using the OpenCV library, no need to have around a version for each one of them. Of course you need to have the *dll* of the OpenCV on all systems where you want to run your application. 
+
+Another approach is to use static libraries that have *lib* extensions. You may build these by using our source files as described in the :ref:`Windows_Installation` tutorial. When you use this the library will be built-in inside your *exe* file.  So there is no chance that the user deletes them, for some reason. As a drawback your application will be larger one and as, it will take more time to load it during its startup.
+
+To build an application with OpenCV you need to do two things: 
+
+.. container:: enumeratevisibleitemswithsquare
+
+  + *Tell* to the compiler how the OpenCV library *looks*. You do this by *showing* it the header files. 
+  + *Tell* to the linker from where to get the functions or data structures of OpenCV, when they are needed. 
+
+    If you use the *lib* system you must set the path where the library files are and specify in which one of them to look. During the build the linker will look into these libraries and add the definitions and implementation of all *used* functions and data structures to the executable file.
+
+    If you use the *DLL* system you must again specify all this, however now for a different reason. This is a Microsoft OS specific stuff. It seems that the linker needs to know that where in the DLL to search for the data structure or function at the runtime. This information is stored inside *lib* files. Nevertheless, they aren't static libraries. They are so called import libraries. This is why when you make some *DLLs* in Windows you will also end up with some *lib* extension libraries. The good part is that at runtime only the *DLL* is required.
+
+To pass on all this information to the Visual Studio IDE you can either do it globally (so all your future projects will get these information) or locally (so only for you current project). The advantage of the global one is that you only need to do it once; however, it may be undesirable to clump all your projects all the time with all these information. In case of the global one how you do it depends on the Microsoft Visual Studio you use. There is a **2008 and previous versions** and a **2010 way** of doing it. Inside the global section of this tutorial I'll show what the main differences are.
+
+The base item of a project in Visual Studio is a solution. A solution may contain multiple projects. Projects are the building blocks of an application. Every project will realize something and you will have a main project in which you can put together this project puzzle. In case of the many simple applications (like many of the tutorials will be) you do not need to break down the application into modules. In these cases your main project will be the only existing one. Now go create a new solution inside Visual studio by going through the :menuselection:`File --> New --> Project` menu selection. Choose *Win32 Console Application* as type. Enter its name and select the path where to create it. Then in the upcoming dialog make sure you create an empty project. 
+
+.. image:: images/NewProjectVisualStudio.jpg
+   :alt: Which options to select
+   :align: center
+
+The *local* method
+==================
+
+Every project is built separately from the others. Due to this every project has its own rule package. Inside this rule packages are stored all the information the *IDE* needs to know to build your project. For any application there are at least two build modes: a *Release* and a *Debug* one. The *Debug* has many features that exist so you can find and resolve easier bugs inside your application. In contrast the *Release* is an optimized version, where the goal is to make the application run as fast as possible or to be as small as possible. You may figure that these modes also require different rules to use during build. Therefore, there exist different rule packages for each of your build modes. These rule packages are called inside the IDE as *project properties* and you can view and modify them by using the *Property Manger*. You can bring up this with :menuselection:`View --> Property Pages`. Expand it and you can see the existing rule packages (called *Proporty Sheets*). 
+
+.. image:: images/PropertyPageExample.jpg
+   :alt: An example of Property Sheet
+   :align: center
+
+The really useful stuff of these is that you may create a rule package *once* and you can later just add it to your new projects. Create it once and reuse it later. We want to create a new *Property Sheet* that will contain all the rules that the compiler and linker needs to know. Of course we will need a separate one for the Debug and the Release Builds. Start up with the Debug one as shown in the image below:
+
+.. image:: images/AddNewPropertySheet.jpg
+   :alt: Add a new Property Sheet
+   :align: center
+
+Use for example the *OpenCV_Debug* name. Then by selecting the sheet :menuselection:`Right Click --> Properties`. In the following I will show to set the OpenCV rules locally, as I find unnecessary to pollute projects with custom rules that I do not use it. Go the C++ groups General entry and under the *"Additional Include Directories"* add the path to your OpenCV include. 
+
+.. code-block:: bash
+
+   $(OPENCV_DIR)\include
+
+.. image:: images/PropertySheetOpenCVInclude.jpg
+   :alt: Add the include dir like this. 
+   :align: center
+
+When adding third party libraries settings it is generally a good idea to use the power behind the environment variables. The full location of the OpenCV library may change on each system. Moreover, you may even end up yourself with moving the install directory for some reason. If you would give explicit paths inside your property sheet your project will end up not working when you pass it further to someone else who has a different OpenCV install path. Moreover, fixing this would require to manually modifying every explicit path. A more elegant solution is to use the environment variables. Anything that you put inside a parenthesis started with a dollar sign will be replaced at runtime with the current environment variables value. Here comes in play the environment variable setting we already made in our :ref:`previous tutorial <WindowsSetPathAndEnviromentVariable>`. 
+
+Next go to the :menuselection:`Linker --> General` and under the *"Additional Library Directories"* add the libs directory:
+
+.. code-block:: bash
+
+   $(OPENCV_DIR)\libs
+
+.. image:: images/PropertySheetOpenCVLib.jpg
+   :alt: Add the library folder like this. 
+   :align: center
+
+Then you need to specify the libraries in which the linker should look into. To do this go to the :menuselection:`Linker --> Input` and under the *"Additional Dependencies"* entry add the name of all modules which you want to use:
+
+.. image:: images/PropertySheetOpenCVLibrariesDebugSmple.jpg
+   :alt: Add the debug library names here.
+   :align: center
+
+.. image:: images/PropertySheetOpenCVLibrariesDebug.jpg
+   :alt: Like this. 
+   :align: center
+
+The names of the libraries are as follow:
+
+.. code-block:: bash
+
+   opencv_(The Name of the module)(The version Number of the library you use)d.lib
+
+A full list, for the currently latest trunk version would contain:
+
+.. code-block:: bash
+
+   opencv_core231d.lib
+   opencv_imgproc231d.lib
+   opencv_highgui231d.lib
+   opencv_ml231d.lib
+   opencv_video231d.lib
+   opencv_features2d231d.lib
+   opencv_calib3d231d.lib
+   opencv_objdetect231d.lib
+   opencv_contrib231d.lib
+   opencv_legacy231d.lib
+   opencv_flann231d.lib
+
+The letter *d* at the end just indicates that these are the libraries required for the debug. Now click ok to save and do the same with a new property inside the Release rule section. Make sure to omit the *d* letters from the library names and to save the property sheets with the save icon above them.
+
+.. image:: images/PropertySheetOpenCVLibrariesRelease.jpg
+   :alt: And the release ones. 
+   :align: center
+
+You can find your property sheets inside your projects directory. At this point it is a wise decision to back them up into some special directory, to always have them at hand in the future, whenever you create an OpenCV project. Note that for Visual Studio 2010 the file extension is *props*, while for 2008 this is *vsprops*. 
+
+.. image:: images/PropertySheetInsideFolder.jpg
+   :alt: And the release ones. 
+   :align: center
+
+Next time when you make a new OpenCV project just use the "Add Existing Property Sheet..." menu entry inside the Property Manager to easily add the OpenCV build rules. 
+
+.. image:: images/PropertyPageAddExisting.jpg
+   :alt: Use this option. 
+   :align: center
+
+The *global* method
+===================
+
+In case you find to troublesome to add the property pages to each and every one of your projects you can also add this rules to a *"global property page"*. However, this applies only to the additional include and library directories. The name of the libraries to use you still need to specify manually by using for instance: a Property page. 
+
+In Visual Studio 2008 you can find this under the:  :menuselection:`Tools --> Options --> Projects and Solutions --> VC++ Directories`. 
+
+.. image:: images/VCDirectories2008.jpg
+   :alt: VC++ Directories in VS 2008.
+   :align: center
+
+In Visual Studio 2010 this has been moved to a global property sheet which is automatically added to every project you create: 
+
+.. image:: images/VCDirectories2010.jpg
+   :alt: VC++ Directories in VS 2010.
+   :align: center
+
+The process is the same as described in case of the local approach. Just add the include directories by using the environment variable *OPENCV_DIR*.
+
+Test it!
+========
+
+Now to try this out download our little test :download:`source code <../../../../samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp>` or get it from the sample code folder of the OpenCV sources. Add this to your project and build it. Here's its content:
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp
+   :language: cpp
+   :tab-width: 4
+   :linenos:
+
+You can start a Visual Studio build from two places. Either inside from the *IDE* (keyboard combination: :kbd:`Control-F5`) or by navigating to your build directory and start the application with a double click. The catch is that these two **aren't** the same. When you start it from the *IDE* its current working directory is the projects directory, while otherwise it is the folder where the application file currently is (so usually your build directory). Moreover, in case of starting from the *IDE* the console window will not close once finished. It will wait for a keystroke of yours.
+
+.. |voila| unicode:: voil U+00E1
+
+This is important to remember when you code inside the code open and save commands. You're resources will be saved ( and queried for at opening!!!) relatively to your working directory. This is unless you give a full, explicit path as parameter for the I/O functions. In the code above we open :download:`this OpenCV logo<../../../../samples/cpp/tutorial_code/images/opencv-logo.png>`. Before starting up the application make sure you place the image file in your current working directory. Modify the image file name inside the code to try it out on other images too. Run it and |voila|: 
+
+.. image:: images/SuccessVisualStudioWindows.jpg
+   :alt: You should have this. 
+   :align: center
+
+Command line arguments with Visual Studio
+=========================================
+
+Throughout some of our future tutorials you'll see that the programs main input method will be by giving a runtime argument. To do this you can just start up a commmand windows (:kbd:`cmd + Enter` in the start menu), navigate to your executable file and start it with an argument. So for example in case of my upper project this would look like:
+
+.. code-block:: bash
+   :linenos:
+
+   D: 
+   CD OpenCV\MySolutionName\Release
+   MySolutionName.exe exampleImage.jpg
+
+Here I first changed my drive (if your project isn't on the OS local drive), navigated to my project and start it with an example image argument. While under Linux system it is common to fiddle around with the console window on the Microsoft Windows many people come to use it almost never. Besides, adding the same argument again and again while you are testing your application is, somewhat, a cumbersome task. Luckily, in the Visual Studio there is a menu to automate all this: 
+
+.. image:: images/VisualStudioCommandLineArguments.jpg
+   :alt: Visual Studio Command Line Arguments
+   :align: center
+
+Specify here the name of the inputs and while you start your application from the Visual Studio enviroment you have automatic argument passing. In the next introductionary tutorial you'll see an in-depth explanation of the upper source code: :ref:`Display_Image`.
\ No newline at end of file
diff --git a/doc/tutorials/ml/introduction_to_svm/images/optimal-hyperplane.png b/doc/tutorials/ml/introduction_to_svm/images/optimal-hyperplane.png
new file mode 100644
index 0000000000..d4522f0479
Binary files /dev/null and b/doc/tutorials/ml/introduction_to_svm/images/optimal-hyperplane.png differ
diff --git a/doc/tutorials/ml/introduction_to_svm/images/result.png b/doc/tutorials/ml/introduction_to_svm/images/result.png
new file mode 100644
index 0000000000..5f477a4f69
Binary files /dev/null and b/doc/tutorials/ml/introduction_to_svm/images/result.png differ
diff --git a/doc/tutorials/ml/introduction_to_svm/images/separating-lines.png b/doc/tutorials/ml/introduction_to_svm/images/separating-lines.png
new file mode 100644
index 0000000000..93ae457c0c
Binary files /dev/null and b/doc/tutorials/ml/introduction_to_svm/images/separating-lines.png differ
diff --git a/doc/tutorials/ml/introduction_to_svm/introduction_to_svm.rst b/doc/tutorials/ml/introduction_to_svm/introduction_to_svm.rst
new file mode 100644
index 0000000000..c2ef546f05
--- /dev/null
+++ b/doc/tutorials/ml/introduction_to_svm/introduction_to_svm.rst
@@ -0,0 +1,188 @@
+.. _introductiontosvms:
+
+Introduction to Support Vector Machines
+***************************************
+
+Goal
+====
+
+In this tutorial you will learn how to:
+
+.. container:: enumeratevisibleitemswithsquare
+
+   + Use the OpenCV functions :svms:`CvSVM::train <cvsvm-train>` to build a classifier based on SVMs and :svms:`CvSVM::predict <cvsvm-predict>` to test its performance.  
+
+What is a SVM?
+==============
+
+A Support Vector Machine (SVM) is a discriminative classifier formally defined by a separating hyperplane. In other words, given labeled training data (*supervised learning*), the algorithm outputs an optimal hyperplane which categorizes new examples.
+
+In which sense is the hyperplane obtained optimal? Let's consider the following
+simple problem:
+
+  For a linearly separable set of 2D-points which belong to one of two classes, find a separating straight line.
+
+.. image:: images/separating-lines.png
+   :alt: A seperation example
+   :align: center
+
+.. note:: In this example we deal with lines and points in the Cartesian plane instead of hyperplanes and vectors in a high dimensional space. This is a simplification of the problem.It is important to understand that this is done only because our intuition is better built from examples that are easy to imagine. However, the same concepts apply to tasks where the examples to classify lie in a space whose dimension is higher than two.
+
+In the above picture you can see that there exists multiple lines that offer a solution to the problem. Is any of them better than the others? We can intuitively define a criterion to estimate the worth of the lines:
+
+  A line is bad if it passes too close to the points because it will be noise sensitive and it will not generalize correctly. Therefore, our goal should be to find the line passing as far as possible from all points.
+
+Then, the operation of the SVM algorithm is based on finding the hyperplane that gives the largest minimum distance to the training examples. Twice, this distance receives the important name of **margin** within SVM's theory. Therefore, the optimal separating hyperplane *maximizes* the margin of the training data.
+
+.. image:: images/optimal-hyperplane.png
+   :alt: The Optimal hyperplane
+   :align: center 
+
+How is the optimal hyperplane computed?
+=======================================
+
+Let's introduce the notation used to define formally a hyperplane:
+
+.. math:: 
+  f(x) = \beta_{0} + \beta^{T} x,
+
+where :math:`\beta` is known as the *weight vector* and :math:`\beta_{0}` as the *bias*.
+
+.. seealso:: A more in depth description of this and hyperplanes you can find in the section 4.5 (*Seperating Hyperplanes*) of the book: *Elements of Statistical Learning* by T. Hastie, R. Tibshirani and J. H. Friedman.
+
+The optimal hyperplane can be represented in an infinite number of different ways by scaling of :math:`\beta` and :math:`\beta_{0}`. As a matter of convention, among all the possible representations of the hyperplane, the one chosen is
+
+.. math::
+  |\beta_{0} + \beta^{T} x| = 1
+
+where :math:`x` symbolizes the training examples closest to the hyperplane. In general, the training examples that are closest to the hyperplane are called **support vectors**. This representation is known as the **canonical hyperplane**.
+
+Now, we use the result of geometry that gives the distance between a point :math:`x` and a hyperplane :math:`(\beta, \beta_{0})`:
+
+.. math::
+   \mathrm{distance} = \frac{|\beta_{0} + \beta^{T} x|}{||\beta||}.
+
+In particular, for the canonical hyperplane, the numerator is equal to one and the distance to the support vectors is
+
+.. math::
+  \mathrm{distance}_{\text{ support vectors}} = \frac{|\beta_{0} + \beta^{T} x|}{||\beta||} = \frac{1}{||\beta||}.
+
+Recall that the margin introduced in the previous section, here denoted as :math:`M`, is twice the distance to the closest examples:
+
+.. math::
+  M = \frac{2}{||\beta||}
+
+Finally, the problem of maximizing :math:`M` is equivalent to the problem of minimizing a function :math:`L(\beta)` subject to some constraints. The constraints model the requirement for the hyperplane to classify correctly all the training examples :math:`x_{i}`. Formally,
+
+.. math::
+  \min_{\beta, \beta_{0}} L(\beta) = \frac{1}{2}||\beta||^{2} \text{ subject to } y_{i}(\beta^{T} x_{i} + \beta_{0}) \geq 1 \text{ } \forall i,
+
+where :math:`y_{i}` represents each of the labels of the training examples.
+
+This is a problem of Lagrangian optimization that can be solved using Lagrange multipliers to obtain the weight vector :math:`\beta` and the bias :math:`\beta_{0}` of the optimal hyperplane.
+
+Source Code
+===========
+
+.. literalinclude:: ../../../../samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp
+   :language: cpp
+   :linenos:
+   :tab-width: 4
+
+Explanation
+===========
+
+1. **Set up the training data**
+
+  The training data of this exercise is formed by a set of labeled 2D-points that belong to one of two different classes; one of the classes consists of one point and the other of three points.
+
+  .. code-block:: cpp
+
+     float labels[4] = {1.0, -1.0, -1.0, -1.0};
+     float trainingData[4][2] = {{501, 10}, {255, 10}, {501, 255}, {10, 501}};
+
+  The function :svms:`CvSVM::train <cvsvm-train>` that will be used afterwards requires the training data to be stored as :basicstructures:`Mat <mat>` objects of floats. Therefore, we create these objects from the arrays defined above:
+
+  .. code-block:: cpp
+
+     Mat trainingDataMat(3, 2, CV_32FC1, trainingData);
+     Mat labelsMat      (3, 1, CV_32FC1, labels);    
+
+2. **Set up SVM's parameters**
+
+   In this tutorial we have introduced the theory of SVMs in the most simple case, when the training examples are spread into two classes that are linearly separable. However, SVMs can be used in a wide variety of problems (e.g. problems with non-linearly separable data, a SVM using a kernel function to raise the dimensionality of the examples, etc). As a consequence of this, we have to define some parameters before training the SVM. These parameters are stored in an object of the class :svms:`CvSVMParams <cvsvmparams>` .
+
+   .. code-block:: cpp
+
+      CvSVMParams params;
+      params.svm_type    = CvSVM::C_SVC;
+      params.kernel_type = CvSVM::LINEAR;
+      params.term_crit   = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
+
+   * *Type of SVM*. We choose here the type **CvSVM::C_SVC** that can be used for n-class classification (n :math:`\geq` 2). This parameter is defined in the attribute *CvSVMParams.svm_type*.
+
+     .. note:: The important feature of the type of SVM **CvSVM::C_SVC** deals with imperfect separation of classes (i.e. when the training data is non-linearly separable). This feature is not important here since the data is linearly separable and we chose this SVM type only for being the most commonly used.
+
+   * *Type of SVM kernel*. We have not talked about kernel functions since they are not interesting for the training data we are dealing with. Nevertheless, let's explain briefly now the main idea behind a kernel function. It is a mapping done to the training data to improve its resemblance to a linearly separable set of data. This mapping consists of increasing the dimensionality of the data and is done efficiently using a kernel function. We choose here the type **CvSVM::LINEAR** which means that no mapping is done. This parameter is defined in the attribute *CvSVMParams.kernel_type*.
+
+   * *Termination criteria of the algorithm*. The SVM training procedure is implemented solving a constrained quadratic optimization problem in an **iterative** fashion. Here we specify a maximum number of iterations and a tolerance error so we allow the algorithm to finish in less number of steps even if the optimal hyperplane has not been computed yet. This parameter is defined in a structure :oldbasicstructures:`cvTermCriteria <cvtermcriteria>`.
+
+3. **Train the SVM**
+
+   We call the method `CvSVM::train <http://opencv.itseez.com/modules/ml/doc/support_vector_machines.html#cvsvm-train>`_ to build the SVM model.
+
+   .. code-block:: cpp
+
+      CvSVM SVM;
+      SVM.train(trainingDataMat, labelsMat, Mat(), Mat(), params);
+
+4. **Regions classified by the SVM**
+
+  The method :svms:`CvSVM::predict <cvsvm-predict>` is used to classify an input sample using a trained SVM. In this example we have used this method in order to color the space depending on the prediction done by the SVM. In other words, an image is traversed interpreting its pixels as points of the Cartesian plane. Each of the points is colored depending on the class predicted by the SVM; in green if it is the class with label 1 and in blue if it is the class with label -1.
+
+  .. code-block:: cpp
+
+     Vec3b green(0,255,0), blue (255,0,0);
+     
+     for (int i = 0; i < image.rows; ++i)
+         for (int j = 0; j < image.cols; ++j)
+         {
+         Mat sampleMat = (Mat_<float>(1,2) << i,j);
+         float response = SVM.predict(sampleMat);
+
+         if (response == 1)
+            image.at<Vec3b>(j, i)  = green;
+         else 
+         if (response == -1) 
+            image.at<Vec3b>(j, i)  = blue;
+         }
+
+5. **Support vectors**
+
+   We use here a couple of methods to obtain information about the support vectors. The method :svms:`CvSVM::get_support_vector_count <cvsvm-get-support-vector>` outputs the total number of support vectors used in the problem and with the method :svms:`CvSVM::get_support_vector <cvsvm-get-support-vector>` we obtain each of the support vectors using an index. We have used this methods here to find the training examples that are support vectors and highlight them.
+
+   .. code-block:: cpp
+
+      int c     = SVM.get_support_vector_count();
+
+      for (int i = 0; i < c; ++i)
+      {
+      const float* v = SVM.get_support_vector(i); // get and then highlight with grayscale
+      circle(	image,  Point( (int) v[0], (int) v[1]),   6,  Scalar(128, 128, 128), thickness, lineType);
+      }
+
+Results
+=======
+
+.. container:: enumeratevisibleitemswithsquare
+
+   * The code opens an image and shows the training examples of both classes. The points of one class are represented with white circles and black ones are used for the other class.
+
+   * The SVM is trained and used to classify all the pixels of the image. This results in a division of the image in a blue region and a green region. The boundary between both regions is the optimal separating hyperplane.
+
+   * Finally the support vectors are shown using gray rings around the training examples.
+
+.. image:: images/result.png
+  :alt: The seperated planes
+  :align: center 
+
diff --git a/doc/tutorials/ml/table_of_content_ml/images/introduction_to_svm.png b/doc/tutorials/ml/table_of_content_ml/images/introduction_to_svm.png
new file mode 100644
index 0000000000..f2d63751fc
Binary files /dev/null and b/doc/tutorials/ml/table_of_content_ml/images/introduction_to_svm.png differ
diff --git a/doc/tutorials/ml/table_of_content_ml/table_of_content_ml.rst b/doc/tutorials/ml/table_of_content_ml/table_of_content_ml.rst
index 33134ff3ae..b2b581afa9 100644
--- a/doc/tutorials/ml/table_of_content_ml/table_of_content_ml.rst
+++ b/doc/tutorials/ml/table_of_content_ml/table_of_content_ml.rst
@@ -5,4 +5,32 @@
 
 Use the powerfull machine learning classes for statistical classification, regression and clustering of data.
 
-.. include:: ../../definitions/noContent.rst
+.. include:: ../../definitions/tocDefinitions.rst 
+
++ 
+  .. tabularcolumns:: m{100pt} m{300pt}
+  .. cssclass:: toctableopencv
+
+  ============ ==============================================
+  |IntroSVM|   **Title:** :ref:`introductiontosvms`
+
+               *Compatibility:* > OpenCV 2.0
+
+               *Author:* |Author_FernandoI|
+
+               Learn what a Suport Vector Machine is. 
+
+  ============ ==============================================
+
+  .. |IntroSVM| image:: images/introduction_to_svm.png
+     :height: 90pt
+     :width:  90pt
+
+.. raw:: latex
+
+   \pagebreak
+
+.. toctree::
+   :hidden:
+   
+   ../introduction_to_svm/introduction_to_svm
diff --git a/doc/tutorials/tutorials.rst b/doc/tutorials/tutorials.rst
index 9696080348..068c72814c 100644
--- a/doc/tutorials/tutorials.rst
+++ b/doc/tutorials/tutorials.rst
@@ -1,15 +1,184 @@
-#################
+################
 OpenCV Tutorials
-#################
+################
 
 The following links describe a set of basic OpenCV  tutorials. All the source code mentioned here is provide as part of the OpenCV regular releases, so check before you start copy & pasting the code. The list of tutorials below is automatically generated from reST files located in our SVN repository.
 
 As always, we would be happy to hear your comments and receive your contributions on any tutorial.
 
+*  :ref:`Table-Of-Content-Introduction`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+  
+   =========== =======================================================
+   |Introduct| You will learn how to setup OpenCV on your computer!
+  
+   =========== =======================================================
+  
+   .. |Introduct| image:: images/introduction.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: Introduction Icon
+
+*  :ref:`Table-Of-Content-Core`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+  
+   =========== =======================================================
+   |Core|      Here you will learn the about the basic building blocks of the library. A must read and know for     understanding how to manipulate the images on a pixel level.
+  
+   =========== =======================================================
+  
+   .. |Core| image:: images/core.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: core Icon
+
+*  :ref:`Table-Of-Content-ImgProc`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |ImgProc|   In this section you will learn about the image processing (manipulation) functions inside OpenCV.
+  
+   =========== =======================================================
+  
+   .. |ImgProc| image:: images/imgproc.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: imgproc Icon
+
+*  :ref:`Table-Of-Content-HighGui`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |HighGui|   This section contains valuable tutorials about how to read/save your image/video files and how to use the built-in graphical user interface of the library. 
+  
+   =========== =======================================================
+  
+   .. |HighGui| image:: images/highgui.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: highgui Icon
+
+*  :ref:`Table-Of-Content-Calib3D`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |Calib3D|   Although we got most of our images in a 2D format they do come from a 3D world. Here you will learn how to find out from the 2D images information about the 3D world. 
+  
+   =========== =======================================================
+  
+   .. |Calib3D| image:: images/calib3d.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: calib3d Icon
+
+*  :ref:`Table-Of-Content-Feature2D`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |Featur2D|  Learn about how to use the feature points  detectors, descriptors and matching framework found inside OpenCV.
+  
+   =========== =======================================================
+  
+   .. |Featur2D| image:: images/feature2D.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: feature2D Icon
+
+*  :ref:`Table-Of-Content-Video`
+ 
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |Video|     Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. 
+  
+   =========== =======================================================
+  
+   .. |Video| image:: images/video.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: video Icon
+
+*  :ref:`Table-Of-Content-ObjDetect`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+  
+   =========== =======================================================
+   |ObjDetect| Ever wondered how your digital camera detects peoples and faces? Look here to find out!
+  
+   =========== =======================================================
+  
+   .. |ObjDetect| image:: images/objdetect.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: objdetect Icon
+
+*  :ref:`Table-Of-Content-Ml`
+   
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |ml|        Use the powerfull machine learning classes for statistical classification, regression and clustering of data.
+  
+   =========== =======================================================
+  
+   .. |ml| image:: images/ml.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: ml Icon
+
+*  :ref:`Table-Of-Content-GPU`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |GPU|       Squeeze out every little computation power from your system by using the power of your video card to run the OpenCV algorithms. 
+  
+   =========== =======================================================
+  
+   .. |GPU| image:: images/gpu.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: gpu icon
+
+*  :ref:`Table-Of-Content-General`
+
+   .. tabularcolumns:: m{100pt} m{300pt}
+   .. cssclass:: toctableopencv
+   
+   =========== =======================================================
+   |General|   These tutorials are the bottom of the iceberg as they link together multiple of the modules presented above in order to solve complex problems.
+  
+   =========== =======================================================
+  
+   .. |General| image:: images/general.jpg
+                 :height: 80pt
+                 :width:  80pt
+                 :alt: General Icon
+
+.. raw:: latex
+
+   \pagebreak
+
 .. toctree::
    :maxdepth: 2
    :hidden:
-   
+
    introduction/table_of_content_introduction/table_of_content_introduction
    core/table_of_content_core/table_of_content_core
    imgproc/table_of_content_imgproc/table_of_content_imgproc
@@ -21,135 +190,3 @@ As always, we would be happy to hear your comments and receive your contribution
    ml/table_of_content_ml/table_of_content_ml
    gpu/table_of_content_gpu/table_of_content_gpu
    general/table_of_content_general/table_of_content_general
-   
-*  :ref:`Table-Of-Content-Introduction`
-
-   =========== =======================================================
-   |Introduct| You will learn how to setup OpenCV on your computer!
-  
-   =========== =======================================================
-  
-   .. |Introduct| image:: images/introduction.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: Introduction Icon
-
-*  :ref:`Table-Of-Content-Core`
-
-   =========== =======================================================
-   |Core|      Here you will learn the about the basic building blocks of the library. A must read and know for     understanding how to manipulate the images on a pixel level.
-  
-   =========== =======================================================
-  
-   .. |Core| image:: images/core.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: core Icon
-
-*  :ref:`Table-Of-Content-ImgProc`
-
-   =========== =======================================================
-   |ImgProc|   In this section you will learn about the image processing (manipulation) functions inside OpenCV.
-  
-   =========== =======================================================
-  
-   .. |ImgProc| image:: images/imgproc.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: imgproc Icon
-
-*  :ref:`Table-Of-Content-HighGui`
-
-   =========== =======================================================
-   |HighGui|   This section contains valuable tutorials about how to read/save your image/video files and how to use the built-in graphical user interface of the library. 
-  
-   =========== =======================================================
-  
-   .. |HighGui| image:: images/highgui.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: highgui Icon
-
-*  :ref:`Table-Of-Content-Calib3D`
-
-   =========== =======================================================
-   |Calib3D|   Although we got most of our images in a 2D format they do come from a 3D world. Here you will learn how to find out from the 2D images information about the 3D world. 
-  
-   =========== =======================================================
-  
-   .. |Calib3D| image:: images/calib3d.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: calib3d Icon
-
-*  :ref:`Table-Of-Content-Feature2D`
-
-   =========== =======================================================
-   |Featur2D|  Learn about how to use the feature points  detectors, descriptors and matching framework found inside OpenCV.
-  
-   =========== =======================================================
-  
-   .. |Featur2D| image:: images/feature2D.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: feature2D Icon
-
-*  :ref:`Table-Of-Content-Video`
-
-   =========== =======================================================
-   |Video|     Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. 
-  
-   =========== =======================================================
-  
-   .. |Video| image:: images/video.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: video Icon
-
-*  :ref:`Table-Of-Content-ObjDetect`
-
-   =========== =======================================================
-   |ObjDetect| Ever wondered how your digital camera detects peoples and faces? Look here to find out!
-  
-   =========== =======================================================
-  
-   .. |ObjDetect| image:: images/objdetect.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: objdetect Icon
-
-*  :ref:`Table-Of-Content-Ml`
-
-   =========== =======================================================
-   |ml|        Use the powerfull machine learning classes for statistical classification, regression and clustering of data.
-  
-   =========== =======================================================
-  
-   .. |ml| image:: images/ml.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: ml Icon
-
-*  :ref:`Table-Of-Content-GPU`
-
-   =========== =======================================================
-   |GPU|       Squeeze out every little computation power from your system by using the power of your video card to run the OpenCV algorithms. 
-  
-   =========== =======================================================
-  
-   .. |GPU| image:: images/gpu.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: gpu icon
-
-*  :ref:`Table-Of-Content-General`
-
-   =========== =======================================================
-   |General|   These tutorials are the bottom of the iceberg as they link together multiple of the modules presented above in order to solve complex problems.
-  
-   =========== =======================================================
-  
-   .. |General| image:: images/general.png
-                 :height: 80pt
-                 :width:  80pt
-                 :alt: General Icon
diff --git a/doc/tutorials/video/table_of_content_video/table_of_content_video.rst b/doc/tutorials/video/table_of_content_video/table_of_content_video.rst
index aabe62d361..423c7ac9c1 100644
--- a/doc/tutorials/video/table_of_content_video/table_of_content_video.rst
+++ b/doc/tutorials/video/table_of_content_video/table_of_content_video.rst
@@ -6,3 +6,7 @@
 Look here in order to find use on your video stream algoritms like: motion extraction, feature tracking and foreground extractions. 
 
 .. include:: ../../definitions/noContent.rst
+
+.. raw:: latex
+
+   \pagebreak
diff --git a/doc/user_guide/ug_features2d.rst b/doc/user_guide/ug_features2d.rst
index 2086e85db7..ac56336716 100644
--- a/doc/user_guide/ug_features2d.rst
+++ b/doc/user_guide/ug_features2d.rst
@@ -14,7 +14,7 @@ Matching keypoints
 ==================
 
 The code
--------
+--------
 We will start with a short sample ``opencv/samples/cpp/matcher_simple.cpp``: ::
 
     Mat img1 = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
diff --git a/doc/user_guide/ug_highgui.rst b/doc/user_guide/ug_highgui.rst
index 58776624f9..a49dd3d047 100644
--- a/doc/user_guide/ug_highgui.rst
+++ b/doc/user_guide/ug_highgui.rst
@@ -12,7 +12,7 @@ Kinect sensor is supported through ``VideoCapture`` class. Depth map, RGB image
 In order to use Kinect with OpenCV you should do the following preliminary steps:
 
 #.
-    Install OpenNI library (from here \url{http://www.openni.org/downloadfiles}) and PrimeSensor Module for OpenNI (from here https://github.com/avin2/SensorKinect}). The installation should be done to default folders listed in the instructions of these products:
+    Install OpenNI library (from here \url{http://www.openni.org/downloadfiles}) and PrimeSensor Module for OpenNI (from here https://github.com/avin2/SensorKinect}). The installation should be done to default folders listed in the instructions of these products, e.g.:
 
     .. code-block:: text
     
@@ -32,7 +32,7 @@ In order to use Kinect with OpenCV you should do the following preliminary steps
     If one or both products were installed to the other folders, the user should change corresponding CMake variables ``OPENNI_LIB_DIR``, ``OPENNI_INCLUDE_DIR`` or/and ``OPENNI_PRIME_SENSOR_MODULE_BIN_DIR``.
     
 #.
-    Configure OpenCV with OpenNI support by setting \texttt{WITH\_OPENNI} flag in CMake. If OpenNI is found in default install folders OpenCV will be built with OpenNI library regardless of whether PrimeSensor Module is found or not. If PrimeSensor Module was not found you will get a warning in CMake log. Without PrimeSensor module OpenCV will be successfully compiled with OpenNI library, but ``VideoCapture`` object will not grab data from Kinect sensor.
+    Configure OpenCV with OpenNI support by setting \texttt{WITH\_OPENNI} flag in CMake. If OpenNI is found in install folders OpenCV will be built with OpenNI library (see a status ``OpenNI`` in CMake log) whereas PrimeSensor Modules can not be found (see a status ``OpenNI PrimeSensor Modules`` in CMake log). Without PrimeSensor module OpenCV will be successfully compiled with OpenNI library, but ``VideoCapture`` object will not grab data from Kinect sensor.
 
 #.
     Build OpenCV.
@@ -53,7 +53,7 @@ VideoCapture can retrieve the following Kinect data:
 
 In order to get depth map from Kinect use ``VideoCapture::operator >>``, e. g. ::
 
-    VideoCapture capture(0); // or CV_CAP_OPENNI
+    VideoCapture capture( CV_CAP_OPENNI );
     for(;;)
     {
         Mat depthMap;    
@@ -80,4 +80,46 @@ For getting several Kinect maps use ``VideoCapture::grab`` and ``VideoCapture::r
             break;
     }
 
+For setting and getting some property of Kinect data generators use ``VideoCapture::set`` and ``VideoCapture::get`` methods respectively, e.g. ::
+
+    VideoCapture capture( CV_CAP_OPENNI );    
+    capture.set( CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE, CV_CAP_OPENNI_VGA_30HZ );
+    cout << "FPS    " << capture.get( CV_CAP_OPENNI_IMAGE_GENERATOR+CV_CAP_PROP_FPS ) << endl;
+
+Since two types of Kinect's data generators are supported (image generator and depth generator), there are two flags that should be used to set/get property of the needed generator:
+
+* CV_CAP_OPENNI_IMAGE_GENERATOR -- A flag for access to the image generator properties.
+
+* CV_CAP_OPENNI_DEPTH_GENERATOR -- A flag for access to the depth generator properties. This flag value is assumed by default if neither of the two possible values of the property is not set.
+
+Flags specifing the needed generator type must be used in combination with particular generator property. The following properties of cameras available through OpenNI interfaces are supported:
+
+* 
+  For image generator:
+  
+  - ``CV_CAP_PROP_OPENNI_OUTPUT_MODE`` -- Two output modes are supported: ``CV_CAP_OPENNI_VGA_30HZ`` used by default (image generator returns images in VGA resolution with 30 FPS) or ``CV_CAP_OPENNI_SXGA_15HZ`` (image generator returns images in SXGA resolution with 15 FPS); depth generator's maps are always in VGA resolution.
+  
+
+* 
+  For depth generator:
+
+  - ``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"``).
+  
+    Next properties are available for getting only:
+  
+  - ``CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH`` -- A maximum supported depth of Kinect in mm.
+  - ``CV_CAP_PROP_OPENNI_BASELINE`` -- Baseline value in mm. 
+  - ``CV_CAP_PROP_OPENNI_FOCAL_LENGTH`` -- A focal length in pixels. 
+  - ``CV_CAP_PROP_FRAME_WIDTH`` -- Frame width in pixels.
+  - ``CV_CAP_PROP_FRAME_HEIGHT`` -- Frame height in pixels.
+  - ``CV_CAP_PROP_FPS`` -- Frame rate in FPS.
+
+*
+  Some typical flags combinations "generator type + property" are defined as single flags:
+  
+    - ``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_ON = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION_ON``
+    
 For more information please refer to a Kinect example of usage ``kinect_maps.cpp`` in ``opencv/samples/cpp`` folder.
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index f08afa4ae4..f95853f2b6 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1,8 +1,9 @@
 file(GLOB old_hdrs "opencv/*.h*")
 install(FILES ${old_hdrs}
-    DESTINATION include/opencv
+    DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv
+    COMPONENT main)
+install(FILES "opencv2/opencv.hpp"
+    DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2
     COMPONENT main)
 
-install(FILES "opencv2/opencv.hpp"
-    DESTINATION include/opencv2
-    COMPONENT main)
+
diff --git a/include/opencv2/opencv.hpp b/include/opencv2/opencv.hpp
index 4d1c2afdab..5935d63c45 100644
--- a/include/opencv2/opencv.hpp
+++ b/include/opencv2/opencv.hpp
@@ -45,11 +45,10 @@
 
 #include "opencv2/core/core_c.h"
 #include "opencv2/core/core.hpp"
-#include "opencv2/flann/flann.hpp"
+#include "opencv2/flann/miniflann.hpp"
 #include "opencv2/imgproc/imgproc_c.h"
 #include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/video/tracking.hpp"
-#include "opencv2/video/background_segm.hpp"
+#include "opencv2/video/video.hpp"
 #include "opencv2/features2d/features2d.hpp"
 #include "opencv2/objdetect/objdetect.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 040b81e21c..17d71f1fcb 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -3,8 +3,10 @@ if(ANDROID)
   if(ANDROID_API_LEVEL LESS 8)
     ADD_DEFINITIONS(-DGTEST_HAS_CLONE=0)
   endif()
-
-  add_subdirectory(androidcamera)
+  
+  IF(WITH_ANDROID_CAMERA)
+      add_subdirectory(androidcamera)
+  endif()
 endif()
 
 add_subdirectory(calib3d)
@@ -22,10 +24,14 @@ add_subdirectory(contrib)
 add_subdirectory(ml)
 add_subdirectory(objdetect)
 
-if(PYTHONLIBS_FOUND AND BUILD_NEW_PYTHON_SUPPORT)
+if(PYTHONLIBS_FOUND AND BUILD_NEW_PYTHON_SUPPORT AND PYTHON_USE_NUMPY)
   add_subdirectory(python)
 endif()
 
+if(BUILD_JAVA_SUPPORT)
+  add_subdirectory(java)
+endif()
+
 add_subdirectory(video)
 add_subdirectory(traincascade)
 add_subdirectory(haartraining)
diff --git a/modules/androidcamera/CMakeLists.txt b/modules/androidcamera/CMakeLists.txt
index 908ebd2592..3f712cbc22 100644
--- a/modules/androidcamera/CMakeLists.txt
+++ b/modules/androidcamera/CMakeLists.txt
@@ -32,13 +32,13 @@ SET_TARGET_PROPERTIES(${the_target} PROPERTIES
 IF (NOT BUILD_SHARED_LIBS)
   install(TARGETS ${the_target}
     RUNTIME DESTINATION bin COMPONENT main
-    ARCHIVE DESTINATION lib COMPONENT main
-    LIBRARY DESTINATION lib COMPONENT main
+    ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
+    LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
     )
 ENDIF()
 
-if (ARMEABI_V7A AND NOT BUILD_ANDROID_CAMERA_WRAPPER)
-  file(GLOB camera_wrappers "${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/lib/libnative_camera_r*.so")
+if (NOT BUILD_ANDROID_CAMERA_WRAPPER)
+  file(GLOB camera_wrappers "${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/lib/${ARMEABI_NDK_NAME}/libnative_camera_r*.so")
 
   foreach(wrapper ${camera_wrappers})
     ADD_CUSTOM_COMMAND(
@@ -48,7 +48,7 @@ if (ARMEABI_V7A AND NOT BUILD_ANDROID_CAMERA_WRAPPER)
     )
     get_filename_component(wrapper_name "${wrapper}" NAME)
     install(FILES "${LIBRARY_OUTPUT_PATH}/${wrapper_name}"
-          DESTINATION lib
+          DESTINATION ${OPENCV_LIB_INSTALL_PATH}
           COMPONENT main)
   endforeach()
 endif()
diff --git a/modules/androidcamera/camera_wrapper/CMakeLists.txt b/modules/androidcamera/camera_wrapper/CMakeLists.txt
index 1453f682cd..e0a1458521 100644
--- a/modules/androidcamera/camera_wrapper/CMakeLists.txt
+++ b/modules/androidcamera/camera_wrapper/CMakeLists.txt
@@ -33,8 +33,4 @@ SET_TARGET_PROPERTIES(${the_target} PROPERTIES
                       RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
                       )
 
-install(TARGETS ${the_target}
-  RUNTIME DESTINATION bin COMPONENT main
-  ARCHIVE DESTINATION lib COMPONENT main
-  LIBRARY DESTINATION lib COMPONENT main
-  )
\ No newline at end of file
+install(TARGETS ${the_target} LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
diff --git a/modules/androidcamera/camera_wrapper/camera_wrapper.cpp b/modules/androidcamera/camera_wrapper/camera_wrapper.cpp
index 0bf10ac192..53af525974 100644
--- a/modules/androidcamera/camera_wrapper/camera_wrapper.cpp
+++ b/modules/androidcamera/camera_wrapper/camera_wrapper.cpp
@@ -1,5 +1,3 @@
-#define USE_RECORDING_INSTEAD_PREVIEW 0
-
 #if !defined(ANDROID_r2_2_2) && !defined(ANDROID_r2_3_3) && !defined(ANDROID_r3_0_1)
 #error unsupported version of Android
 #endif
@@ -9,125 +7,115 @@
 #include "../include/camera_properties.h"
 #include <string>
 
+//undef logging macro from /system/core/libcutils/loghack.h
+#ifdef LOGD
+#undef LOGD
+#endif
+
+#ifdef LOGI
+#undef LOGI
+#endif
+
+#ifdef LOGW
+#undef LOGW
+#endif
+
+#ifdef LOGE
+#undef LOGE
+#endif
+
+
+// LOGGING
+#include <android/log.h>
+#define CAMERA_LOG_TAG "OpenCV_NativeCamera"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, CAMERA_LOG_TAG, __VA_ARGS__))
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, CAMERA_LOG_TAG, __VA_ARGS__))
+#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, CAMERA_LOG_TAG, __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, CAMERA_LOG_TAG, __VA_ARGS__))
+
 using namespace android;
 
 void debugShowFPS()
 {
     static int mFrameCount = 0;
     static int mLastFrameCount = 0;
-    static nsecs_t mLastFpsTime = systemTime();;
+    static nsecs_t mLastFpsTime = systemTime();
     static float mFps = 0;
 
     mFrameCount++;
 
-    if ( ( mFrameCount % 30 ) == 0 ) {
-        nsecs_t now = systemTime();
-        nsecs_t diff = now - mLastFpsTime;
-        if (diff==0)
-            return;
+    if (( mFrameCount % 30 ) != 0)
+        return;
 
-        mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
-        mLastFpsTime = now;
-        mLastFrameCount = mFrameCount;
-        LOGI("####### [%d] Frames, %f FPS", mFrameCount, mFps);
-    }
+    nsecs_t now = systemTime();
+    nsecs_t diff = now - mLastFpsTime;
+
+    if (diff==0)
+        return;
+
+    mFps =  ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
+    mLastFpsTime = now;
+    mLastFrameCount = mFrameCount;
+    LOGI("### Camera FPS ### [%d] Frames, %.2f FPS", mFrameCount, mFps);
 }
 
 class CameraHandler: public CameraListener
 {
 protected:
-    sp<Camera> camera;
-    CameraCallback cameraCallback;
-    CameraParameters params;
-    void* userData;
     int cameraId;
+    sp<Camera> camera;
+    CameraParameters params;
+    CameraCallback cameraCallback;
+    void* userData;
 
-    bool isEmptyCameraCallbackReported;
-    virtual void doCall(void* buffer, size_t bufferSize)
+    int emptyCameraCallbackReported;
+
+    void doCall(void* buffer, size_t bufferSize)
     {
         if (cameraCallback == 0)
         {
-            if (!isEmptyCameraCallbackReported)
-                LOGE("Camera callback is empty!");
+            if (!emptyCameraCallbackReported)
+                LOGE("CameraHandler::doCall(void*, size_t): Camera callback is empty!");
 
-            isEmptyCameraCallbackReported = true;
-            return;
+            emptyCameraCallbackReported++;
         }
+        else
+        {
+            bool res = (*cameraCallback)(buffer, bufferSize, userData);
 
-        bool res = (*cameraCallback)(buffer, bufferSize, userData);
-
-        if(!res) closeCameraConnect();
+            if(!res)
+            {
+                LOGE("CameraHandler::doCall(void*, size_t): cameraCallback returns false (camera connection will be closed)");
+                closeCameraConnect();
+            }
+        }
     }
 
-    virtual void doCall(const sp<IMemory>& dataPtr)
+    void doCall(const sp<IMemory>& dataPtr)
     {
-        LOGI("doCall started");
-
         if (dataPtr == NULL)
         {
-            LOGE("CameraBuffer: dataPtr==NULL");
+            LOGE("CameraHandler::doCall(const sp<IMemory>&): dataPtr==NULL (no frame to handle)");
             return;
         }
 
         size_t size = dataPtr->size();
         if (size <= 0)
         {
-            LOGE("CameraBuffer: IMemory object is of zero size");
+            LOGE("CameraHandler::doCall(const sp<IMemory>&): IMemory object is of zero size");
             return;
         }
 
-        unsigned char* buffer = (unsigned char *)dataPtr->pointer();
+        void* buffer = (void *)dataPtr->pointer();
         if (!buffer)
         {
-            LOGE("CameraBuffer: Buffer pointer is invalid");
+            LOGE("CameraHandler::doCall(const sp<IMemory>&): Buffer pointer is NULL");
             return;
         }
 
         doCall(buffer, size);
     }
 
-public:
-    CameraHandler(CameraCallback callback = 0, void* _userData = 0):cameraCallback(callback), userData(_userData), cameraId(0),  isEmptyCameraCallbackReported(false) {}
-    virtual ~CameraHandler()
-    {
-	    LOGW("CameraHandler destructor is called!");
-    }
-
-    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2)
-    {
-        LOGE("Notify cb: %d %d %d\n", msgType, ext1, ext2);
-#if 0
-        if ( msgType & CAMERA_MSG_FOCUS )
-            LOGE("AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timevalDelay(&autofocus_start));
-
-        if ( msgType & CAMERA_MSG_SHUTTER )
-            LOGE("Shutter done in %llu us\n", timeval_delay(&picture_start));
-#endif
-    }
-
-    virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr)
-    {
-        debugShowFPS();
-
-        if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
-        {
-            doCall(dataPtr);
-            return;
-        }
-
-        if (msgType != CAMERA_MSG_PREVIEW_FRAME)
-            LOGE("Recieved not CAMERA_MSG_PREVIEW_FRAME message %d", (int) msgType);
-
-        if ( msgType & CAMERA_MSG_RAW_IMAGE )
-            LOGE("Unexpected data format: RAW\n");
-
-        if (msgType & CAMERA_MSG_POSTVIEW_FRAME)
-            LOGE("Unexpected data format: Postview frame\n");
-
-        if (msgType & CAMERA_MSG_COMPRESSED_IMAGE )
-            LOGE("Unexpected data format: JPEG");
-    }
-
     virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
     {
         static uint32_t count = 0;
@@ -152,6 +140,56 @@ public:
         camera->releaseRecordingFrame(dataPtr);
     }
 
+public:
+    CameraHandler(CameraCallback callback = 0, void* _userData = 0):
+        cameraId(0),
+        cameraCallback(callback),
+        userData(_userData),
+        emptyCameraCallbackReported(0)
+    {
+        LOGD("Instantiated new CameraHandler (%p, %p)", callback, _userData);
+    }
+
+    virtual ~CameraHandler()
+    {
+            LOGD("CameraHandler destructor is called");
+    }
+
+    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2)
+    {
+        LOGE("CameraHandler::Notify: msgType=%d ext1=%d ext2=%d\n", msgType, ext1, ext2);
+#if 0
+        if ( msgType & CAMERA_MSG_FOCUS )
+            LOGE("CameraHandler::Notify  AutoFocus %s in %llu us\n", (ext1) ? "OK" : "FAIL", timevalDelay(&autofocus_start));
+
+        if ( msgType & CAMERA_MSG_SHUTTER )
+            LOGE("CameraHandler::Notify  Shutter done in %llu us\n", timeval_delay(&picture_start));
+#endif
+    }
+
+    virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr)
+    {
+        debugShowFPS();
+
+        if ( msgType & CAMERA_MSG_PREVIEW_FRAME )
+        {
+            doCall(dataPtr);
+            return;
+        }
+
+        if (msgType != CAMERA_MSG_PREVIEW_FRAME)
+            LOGE("CameraHandler::postData  Recieved message %d is not equal to CAMERA_MSG_PREVIEW_FRAME (%d)", (int) msgType, CAMERA_MSG_PREVIEW_FRAME);
+
+        if ( msgType & CAMERA_MSG_RAW_IMAGE )
+            LOGE("CameraHandler::postData  Unexpected data format: RAW\n");
+
+        if (msgType & CAMERA_MSG_POSTVIEW_FRAME)
+            LOGE("CameraHandler::postData  Unexpected data format: Postview frame\n");
+
+        if (msgType & CAMERA_MSG_COMPRESSED_IMAGE )
+            LOGE("CameraHandler::postData  Unexpected data format: JPEG");
+    }
+
     static CameraHandler* initCameraConnect(const CameraCallback& callback, int cameraId, void* userData, CameraParameters* prevCameraParameters);
     void closeCameraConnect();
     double getProperty(int propIdx);
@@ -159,16 +197,13 @@ public:
     static void applyProperties(CameraHandler** ppcameraHandler);
 
     std::string cameraPropertySupportedPreviewSizesString;
+    std::string cameraPropertyPreviewFormatString;
 };
 
 
 CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback, int cameraId, void* userData, CameraParameters* prevCameraParameters)
 {
-//    if (camera != NULL)
-//    {
-//        LOGE("initCameraConnect: camera have been connected already");
-//        return false;
-//    }
+    LOGD("CameraHandler::initCameraConnect(%p, %d, %p, %p)", callback, cameraId, userData, prevCameraParameters);
 
     sp<Camera> camera = 0;
 
@@ -179,7 +214,7 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
     camera = Camera::connect(cameraId);
 #endif
 
-    if ( NULL == camera.get() )
+    if ( 0 == camera.get() )
     {
         LOGE("initCameraConnect: Unable to connect to CameraService\n");
         return 0;
@@ -189,35 +224,79 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
     camera->setListener(handler);
 
     handler->camera = camera;
-    handler->cameraId=cameraId;
-#if 1 
-    //setting paramers from previous camera handler
-    if (prevCameraParameters != NULL) {
-	    camera->setParameters(prevCameraParameters->flatten());
+    handler->cameraId = cameraId;
+
+    if (prevCameraParameters != 0)
+    {
+        LOGI("initCameraConnect: Setting paramers from previous camera handler");
+        camera->setParameters(prevCameraParameters->flatten());
+        handler->params.unflatten(prevCameraParameters->flatten());
     }
-#endif
-    handler->params.unflatten(camera->getParameters());
+    else
+    {
+        android::String8 params_str = camera->getParameters();
+        LOGI("initCameraConnect: [%s]", params_str.string());
+
+        handler->params.unflatten(params_str);
+
+        LOGD("Supported Cameras: %s", handler->params.get("camera-indexes"));
+        LOGD("Supported Picture Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
+        LOGD("Supported Picture Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
+        LOGD("Supported Preview Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
+        LOGD("Supported Preview Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
+        LOGD("Supported Preview Frame Rates: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
+        LOGD("Supported Thumbnail Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
+        LOGD("Supported Whitebalance Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
+        LOGD("Supported Effects: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
+        LOGD("Supported Scene Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
+        LOGD("Supported Focus Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
+        LOGD("Supported Antibanding Options: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
+        LOGD("Supported Flash Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
 
 
-    LOGD("Supported Cameras: %s", handler->params.get("camera-indexes"));
-    LOGD("Supported Picture Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES));
-    LOGD("Supported Picture Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS));
-    LOGD("Supported Preview Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES));
-    LOGD("Supported Preview Formats: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS));
-    LOGD("Supported Preview Frame Rates: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES));
-    LOGD("Supported Thumbnail Sizes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
-    LOGD("Supported Whitebalance Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE));
-    LOGD("Supported Effects: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_EFFECTS));
-    LOGD("Supported Scene Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_SCENE_MODES));
-    LOGD("Supported Focus Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES));
-    LOGD("Supported Antibanding Options: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_ANTIBANDING));
-    LOGD("Supported Flash Modes: %s", handler->params.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES));
+        //check if yuv420sp format available. Set this format as preview format.
+        const char* available_formats = handler->params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS);
+        if (available_formats != 0)
+        {
+            const char* format_to_set = 0;
+            const char* pos = available_formats;
+            const char* ptr = pos;
+            while(true)
+            {
+                while(*ptr != 0 && *ptr != ',') ++ptr;
+                if (ptr != pos)
+                {
+                    if (0 == strncmp(pos, "yuv420sp", ptr - pos))
+                    {
+                        format_to_set = "yuv420sp";
+                        break;
+                    }
+                    if (0 == strncmp(pos, "yuv420i", ptr - pos))
+                        format_to_set = "yuv420i";
+                }
+                if (*ptr == 0)
+                    break;
+                pos = ++ptr;
+            }
 
+            if (0 != format_to_set)
+            {
+                handler->params.setPreviewFormat(format_to_set);
 
-    //TODO: check if yuv420i format available. Set this format as preview format.
+                status_t resParams = handler->camera->setParameters(handler->params.flatten());
 
-#if USE_RECORDING_INSTEAD_PREVIEW
-    status_t err = camera->setPreviewDisplay(sp<ISurface>(NULL /*new DummySurface1*/));
+                if (resParams != 0)
+                    LOGE("initCameraConnect: failed to set preview format to %s", format_to_set);
+                else
+                    LOGD("initCameraConnect: preview format is set to %s", format_to_set);
+            }
+        }
+    }
+
+#ifdef ANDROID_r2_2_2
+    status_t pdstatus = camera->setPreviewDisplay(sp<ISurface>(0 /*new DummySurface*/));
+    if (pdstatus != 0)
+        LOGE("initCameraConnect: failed setPreviewDisplay(0) call; camera migth not work correcttly on some devices");
 #endif
 
     ////ATTENTION: switching between two versions: with and without copying memory inside Android OS
@@ -228,17 +307,15 @@ CameraHandler* CameraHandler::initCameraConnect(const CameraCallback& callback,
     camera->setPreviewCallbackFlags( FRAME_CALLBACK_FLAG_ENABLE_MASK );//without copy
 #endif
 
-#if USE_RECORDING_INSTEAD_PREVIEW
-    status_t resStart = camera->startRecording();
-#else
     status_t resStart = camera->startPreview();
-#endif
 
     if (resStart != 0)
     {
+        LOGE("initCameraConnect: startPreview() fails. Closing camera connection...");
         handler->closeCameraConnect();
         handler = 0;
     }
+
     return handler;
 }
 
@@ -246,17 +323,11 @@ void CameraHandler::closeCameraConnect()
 {
     if (camera == NULL)
     {
-        LOGI("... camera is NULL");
+        LOGI("... camera is already NULL");
         return;
     }
 
-    //TODO: ATTENTION! should we do it ALWAYS???
-#if USE_RECORDING_INSTEAD_PREVIEW
-    camera->stopRecording();
-#else
     camera->stopPreview();
-#endif
-
     camera->disconnect();
     camera.clear();
 
@@ -285,28 +356,50 @@ void CameraHandler::closeCameraConnect()
 
 double CameraHandler::getProperty(int propIdx)
 {
+    LOGD("CameraHandler::getProperty(%d)", propIdx);
+
     switch (propIdx)
     {
     case ANDROID_CAMERA_PROPERTY_FRAMEWIDTH:
     {
         int w,h;
-        params.getPreviewSize(&w,&h);
+        params.getPreviewSize(&w, &h);
         return w;
     }
     case ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT:
     {
         int w,h;
-        params.getPreviewSize(&w,&h);
+        params.getPreviewSize(&w, &h);
         return h;
     }
     case ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING:
     {
-	    cameraPropertySupportedPreviewSizesString=params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
-	    double res;
-	    memset(&res, 0, sizeof(res));
-	    (*( (void**)&res ))= (void*)( cameraPropertySupportedPreviewSizesString.c_str() );
-	    
-	    return res;
+        cameraPropertySupportedPreviewSizesString = params.get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
+        union {const char* str;double res;} u;
+        memset(&u.res, 0, sizeof(u.res));
+        u.str = cameraPropertySupportedPreviewSizesString.c_str();
+        return u.res;
+    }
+
+    case ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING:
+    {
+        const char* fmt = params.get(CameraParameters::KEY_PREVIEW_FORMAT);
+        if (fmt == CameraParameters::PIXEL_FORMAT_YUV422SP)
+            fmt = "yuv422sp";
+        else if (fmt == CameraParameters::PIXEL_FORMAT_YUV420SP)
+            fmt = "yuv420sp";
+        else if (fmt == CameraParameters::PIXEL_FORMAT_YUV422I)
+            fmt = "yuv422i";
+        else if (fmt == CameraParameters::PIXEL_FORMAT_RGB565)
+            fmt = "rgb565";
+        else if (fmt == CameraParameters::PIXEL_FORMAT_JPEG)
+            fmt = "jpeg";
+        cameraPropertyPreviewFormatString = fmt;
+
+        union {const char* str;double res;} u;
+        memset(&u.res, 0, sizeof(u.res));
+        u.str = cameraPropertyPreviewFormatString.c_str();
+        return u.res;
     }
 
     };
@@ -315,22 +408,24 @@ double CameraHandler::getProperty(int propIdx)
 
 void CameraHandler::setProperty(int propIdx, double value)
 {
+    LOGD("CameraHandler::setProperty(%d, %f)", propIdx, value);
+
     switch (propIdx)
     {
     case ANDROID_CAMERA_PROPERTY_FRAMEWIDTH:
     {
         int w,h;
-        params.getPreviewSize(&w,&h);
+        params.getPreviewSize(&w, &h);
         w = (int)value;
-        params.setPreviewSize(w,h);
+        params.setPreviewSize(w, h);
     }
     break;
     case ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT:
     {
         int w,h;
-        params.getPreviewSize(&w,&h);
+        params.getPreviewSize(&w, &h);
         h = (int)value;
-        params.setPreviewSize(w,h);
+        params.setPreviewSize(w, h);
     }
     break;
     };
@@ -338,6 +433,20 @@ void CameraHandler::setProperty(int propIdx, double value)
 
 void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
 {
+    LOGD("CameraHandler::applyProperties()");
+
+    if (ppcameraHandler == 0)
+    {
+        LOGE("applyProperties: Passed NULL ppcameraHandler");
+        return;
+    }
+
+    if (*ppcameraHandler == 0)
+    {
+        LOGE("applyProperties: Passed null *ppcameraHandler");
+        return;
+    }
+
     LOGD("CameraHandler::applyProperties()");
     CameraHandler* previousCameraHandler=*ppcameraHandler;
     CameraParameters curCameraParameters(previousCameraHandler->params.flatten());
@@ -355,12 +464,12 @@ void CameraHandler::applyProperties(CameraHandler** ppcameraHandler)
     CameraHandler* handler=initCameraConnect(cameraCallback, cameraId, userData, &curCameraParameters);
     LOGD("CameraHandler::applyProperties(): after initCameraConnect, handler=0x%x", (int)handler);
     if (handler == NULL) {
-	    LOGE("ERROR in applyProperties --- cannot reinit camera");
-	    handler=initCameraConnect(cameraCallback, cameraId, userData, NULL);
-	    LOGD("CameraHandler::applyProperties(): repeate initCameraConnect after ERROR, handler=0x%x", (int)handler);
-	    if (handler == NULL) {
-		    LOGE("ERROR in applyProperties --- cannot reinit camera AGAIN --- cannot do anything else");
-	    }
+        LOGE("ERROR in applyProperties --- cannot reinit camera");
+        handler=initCameraConnect(cameraCallback, cameraId, userData, NULL);
+        LOGD("CameraHandler::applyProperties(): repeate initCameraConnect after ERROR, handler=0x%x", (int)handler);
+        if (handler == NULL) {
+            LOGE("ERROR in applyProperties --- cannot reinit camera AGAIN --- cannot do anything else");
+        }
     }
     (*ppcameraHandler)=handler;
 }
@@ -392,7 +501,7 @@ void setCameraPropertyC(void* camera, int propIdx, double value)
 
 void applyCameraPropertiesC(void** camera)
 {
-	CameraHandler::applyProperties((CameraHandler**)camera);
+    CameraHandler::applyProperties((CameraHandler**)camera);
 }
 
 }
diff --git a/modules/androidcamera/camera_wrapper/camera_wrapper.h b/modules/androidcamera/camera_wrapper/camera_wrapper.h
index f1ae6bda62..c1ba67e430 100644
--- a/modules/androidcamera/camera_wrapper/camera_wrapper.h
+++ b/modules/androidcamera/camera_wrapper/camera_wrapper.h
@@ -1,10 +1,3 @@
-enum CameraWrapperErrorCode {
-    ERROR_NATIVE_CAMERA_WRAPPER_NOERROR = 0,
-    ERROR_NATIVE_CAMERA_WRAPPER_CANNOT_FIND_CLASS = 1,
-    ERROR_NATIVE_CAMERA_WRAPPER_CANNOT_FIND_FIELD = 2,
-    ERROR_NATIVE_CAMERA_WRAPPER_CANNOT_SET_PREVIEW_DISPLAY = 3
-};
-
 typedef bool (*CameraCallback)(void* buffer, size_t bufferSize, void* userData);
 
 typedef void* (*InitCameraConnectC)(void* cameraCallback, int cameraId, void* userData);
diff --git a/modules/androidcamera/include/camera_properties.h b/modules/androidcamera/include/camera_properties.h
index 42202e3696..56cbb74336 100644
--- a/modules/androidcamera/include/camera_properties.h
+++ b/modules/androidcamera/include/camera_properties.h
@@ -4,7 +4,8 @@
 enum {
     ANDROID_CAMERA_PROPERTY_FRAMEWIDTH = 0,
     ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT = 1,
-    ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING = 2
+    ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING = 2,
+    ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING = 3
 };
 
 #endif // CAMERA_PROPERTIES_H
diff --git a/modules/androidcamera/src/camera_activity.cpp b/modules/androidcamera/src/camera_activity.cpp
index ca612b354b..c8a72deee7 100644
--- a/modules/androidcamera/src/camera_activity.cpp
+++ b/modules/androidcamera/src/camera_activity.cpp
@@ -133,7 +133,7 @@ CameraActivity::ErrorCode CameraWrapperConnector::getProperty(void* camera, int
         LOGE("CameraWrapperConnector::getProperty error: wrong pointer to camera object");
         return CameraActivity::ERROR_WRONG_POINTER_CAMERA_WRAPPER;
     }
-
+    LOGE("calling (*pGetPropertyC)(%p, %d)", camera, propIdx);
     *value = (*pGetPropertyC)(camera, propIdx);
     return CameraActivity::NO_ERROR;
 }
@@ -238,7 +238,7 @@ void CameraWrapperConnector::fillListWrapperLibs(const string& folderPath, vecto
     dp = opendir (folderPath.c_str());
     if (dp != NULL)
     {
-        while (ep = readdir (dp)) {
+        while ((ep = readdir (dp))) {
             const char* cur_name=ep->d_name;
             if (strstr(cur_name, PREFIX_CAMERA_WRAPPER_LIB)) {
                 listLibs.push_back(cur_name);
@@ -260,9 +260,9 @@ std::string CameraWrapperConnector::getPathLibFolder()
         LOGD("Library name: %s", dl_info.dli_fname);
         LOGD("Library base address: %p", dl_info.dli_fbase);
 
-        char addrBuf[18];
-        sprintf(addrBuf, "%x-", dl_info.dli_fbase);
-        int addrLength = strlen(addrBuf);
+	const char* libName=dl_info.dli_fname;
+	while( ((*libName)=='/') || ((*libName)=='.') )
+		libName++;
 
         char lineBuf[2048];
         FILE* file = fopen("/proc/self/smaps", "rt");
@@ -271,11 +271,9 @@ std::string CameraWrapperConnector::getPathLibFolder()
         {
 	    while (fgets(lineBuf, sizeof lineBuf, file) != NULL)
 	    {
-                if(0 == strncmp(lineBuf, addrBuf, addrLength))
-                {
                     //verify that line ends with library name
                     int lineLength = strlen(lineBuf);
-                    int libNameLength = strlen(dl_info.dli_fname);
+                    int libNameLength = strlen(libName);
 
                     //trim end
                     for(int i = lineLength - 1; i >= 0 && isspace(lineBuf[i]); --i)
@@ -284,9 +282,9 @@ std::string CameraWrapperConnector::getPathLibFolder()
                         --lineLength;
                     }
 
-                    if (0 != strncmp(lineBuf + lineLength - libNameLength, dl_info.dli_fname, libNameLength))
+                    if (0 != strncmp(lineBuf + lineLength - libNameLength, libName, libNameLength))
                     {
-                        LOGE("Strange error: line \"%s\" does not ends with library name %s", lineBuf, dl_info.dli_fname);
+                        //the line does not contain the library name
                         continue;
                     }
 
@@ -305,7 +303,6 @@ std::string CameraWrapperConnector::getPathLibFolder()
 
                     fclose(file);
                     return pathBegin;
-                }
 	    }
 	    fclose(file);
 	    LOGE("Could not find library path.");
diff --git a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst
index 595df206d9..a83c7017b2 100644
--- a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst
+++ b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst
@@ -35,6 +35,7 @@ where:
    * :math:`(cx, cy)` is a principal point that is usually at the image center
    * :math:`fx, fy` are the focal lengths expressed in pixel-related units
    
+
 Thus, if an image from the camera is
 scaled by a factor, all of these parameters should
 be scaled (multiplied/divided, respectively) by the same factor. The
@@ -110,9 +111,9 @@ calibrateCamera
 ---------------
 Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern.
 
-.. ocv:function:: double calibrateCamera( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArray rvecs, OutputArray tvecs, int flags=0 )
+.. ocv:function:: double calibrateCamera( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0 )
 
-.. ocv:pyfunction:: cv2.calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
+.. ocv:pyfunction:: cv2.calibrateCamera(objectPoints, imagePoints, imageSize[, cameraMatrix[, distCoeffs[, rvecs[, tvecs[, flags]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
 
 .. ocv:cfunction:: double cvCalibrateCamera2( const CvMat* objectPoints, const CvMat* imagePoints, const CvMat* pointCounts, CvSize imageSize, CvMat* cameraMatrix, CvMat* distCoeffs, CvMat* rvecs=NULL, CvMat* tvecs=NULL, int flags=0 )
 
@@ -136,7 +137,7 @@ Finds the camera intrinsic and extrinsic parameters from several views of a cali
 
     :param rvecs: Output  vector  of rotation vectors (see  :ocv:func:`Rodrigues` ) estimated for each pattern view. That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the calibration pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the calibration pattern in the k-th pattern view (k=0.. *M* -1).
 
-    :param tvecs: Output  vector  of translation vectors estimated for each pattern view.
+    :param tvecs: Output vector of translation vectors estimated for each pattern view.
 
     :param flags: Different flags that may be zero or a combination of the following values:
 
@@ -179,7 +180,7 @@ The function returns the final re-projection error.
 
 .. note::
 
-    If you use a non-square (=non-NxN) grid and	:ocv:func:`findChessboardCorners` for calibration, and ``calibrateCamera`` returns bad values (zero distortion coefficients, an image center very far from ``(w/2-0.5,h/2-0.5)``, and/or large differences between :math:`f_x` and :math:`f_y` (ratios of 10:1 or more)), then you have probably used ``patternSize=cvSize(rows,cols)`` instead of using ``patternSize=cvSize(cols,rows)`` in :ocv:func:`findChessboardCorners` .
+    If you use a non-square (=non-NxN) grid and    :ocv:func:`findChessboardCorners` for calibration, and ``calibrateCamera`` returns bad values (zero distortion coefficients, an image center very far from ``(w/2-0.5,h/2-0.5)``, and/or large differences between :math:`f_x` and :math:`f_y` (ratios of 10:1 or more)), then you have probably used ``patternSize=cvSize(rows,cols)`` instead of using ``patternSize=cvSize(cols,rows)`` in :ocv:func:`findChessboardCorners` .
 
 .. seealso::
 
@@ -534,7 +535,7 @@ Finds an object pose from 3D-2D point correspondences.
     :param imagePoints: Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points.  ``vector<Point2f>``  can be also passed here.
 
     :param cameraMatrix: Input camera matrix  :math:`A = \vecthreethree{fx}{0}{cx}{0}{fy}{cy}{0}{0}{1}` .
-	
+    
     :param distCoeffs: Input vector of distortion coefficients  :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])`  of 4, 5, or 8 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
 
     :param rvec: Output rotation vector (see  :ocv:func:`Rodrigues` ) that, together with  ``tvec`` , brings points from the model coordinate system to the camera coordinate system.
@@ -597,7 +598,7 @@ Calculates a fundamental matrix from the corresponding points in two images.
     :param points1: Array of  ``N``  points from the first image. The point coordinates should be floating-point (single or double precision).
 
     :param points2: Array of the second image points of the same size and format as  ``points1`` .
-	
+    
     :param method: Method for computing a fundamental matrix.
 
             * **CV_FM_7POINT** for a 7-point algorithm.  :math:`N = 7`
@@ -605,7 +606,7 @@ Calculates a fundamental matrix from the corresponding points in two images.
             * **CV_FM_RANSAC** for the RANSAC algorithm.  :math:`N \ge 8`
             * **CV_FM_LMEDS** for the LMedS algorithm.  :math:`N \ge 8`
     
-	:param param1: Parameter used for RANSAC. It is the maximum distance from a point to an epipolar line in pixels, beyond which the point is considered an outlier and is not used for computing the final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the point localization, image resolution, and the image noise.
+    :param param1: Parameter used for RANSAC. It is the maximum distance from a point to an epipolar line in pixels, beyond which the point is considered an outlier and is not used for computing the final fundamental matrix. It can be set to something like 1-3, depending on the accuracy of the point localization, image resolution, and the image noise.
 
     :param param2: Parameter used for the RANSAC or LMedS methods only. It specifies a desirable level of confidence (probability) that the estimated matrix is correct.
 
@@ -779,11 +780,12 @@ getOptimalNewCameraMatrix
 -----------------------------
 Returns the new camera matrix based on the free scaling parameter.
 
-.. ocv:function:: Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0)
+.. ocv:function:: Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0, bool centerPrincipalPoint=false)
 
-.. ocv:pyfunction:: cv2.getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha[, newImgSize]) -> retval, validPixROI
+.. ocv:pyfunction:: cv2.getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha[, newImgSize[, centerPrincipalPoint]]) -> retval, validPixROI
+
+.. ocv:cfunction:: void cvGetOptimalNewCameraMatrix( const CvMat* cameraMatrix, const CvMat* distCoeffs, CvSize imageSize, double alpha, CvMat* newCameraMatrix, CvSize newImageSize=cvSize(0, 0), CvRect* validPixROI=0, int centerPrincipalPoint=0)
 
-.. ocv:cfunction:: void cvGetOptimalNewCameraMatrix( const CvMat* cameraMatrix, const CvMat* distCoeffs, CvSize imageSize, double alpha, CvMat* newCameraMatrix, CvSize newImageSize=cvSize(0, 0), CvRect* validPixROI=0 )
 .. ocv:pyoldfunction:: cv.GetOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newCameraMatrix, newImageSize=(0, 0), validPixROI=0) -> None
 
     :param cameraMatrix: Input camera matrix.
@@ -799,6 +801,8 @@ Returns the new camera matrix based on the free scaling parameter.
     :param newImageSize: Image size after rectification. By default,it is set to  ``imageSize`` .
 
     :param validPixROI: Optional output rectangle that outlines all-good-pixels region in the undistorted image. See  ``roi1, roi2``  description in  :ocv:func:`StereoRectify` .
+
+    :param centerPrincipalPoint: Optional flag that indicates whether in the new camera matrix the principal point should be at the image center or not. By default, the principal point is chosen to best fit a subset of the source image (determined by ``alpha``) to the corrected image.
     
 The function computes and returns
 the optimal new camera matrix based on the free scaling parameter. By varying  this parameter, you may retrieve only sensible pixels ``alpha=0`` , keep all the original image pixels if there is valuable information in the corners ``alpha=1`` , or get something in between. When ``alpha>0`` , the undistortion result is likely to have some black pixels corresponding to "virtual" pixels outside of the captured distorted image. The original camera matrix, distortion coefficients, the computed new camera matrix, and ``newImageSize`` should be passed to
@@ -848,7 +852,7 @@ Computes partial derivatives of the matrix product for each multiplied matrix.
 
     :param dABdA: First output derivative matrix  ``d(A*B)/dA``  of size  :math:`\texttt{A.rows*B.cols} \times {A.rows*A.cols}` .
     
-    :param dABdA: Second output derivative matrix  ``d(A*B)/dB``  of size  :math:`\texttt{A.rows*B.cols} \times {B.rows*B.cols}` .
+    :param dABdB: Second output derivative matrix  ``d(A*B)/dB``  of size  :math:`\texttt{A.rows*B.cols} \times {B.rows*B.cols}` .
 
 The function computes partial derivatives of the elements of the matrix product
 :math:`A*B` with regard to the elements of each of the two input matrices. The function is used to compute the Jacobian matrices in
@@ -911,7 +915,7 @@ Reprojects a disparity image to 3D space.
 .. ocv:cfunction:: void cvReprojectImageTo3D( const CvArr* disparity, CvArr* _3dImage, const CvMat* Q, int handleMissingValues=0)
 .. ocv:pyoldfunction:: cv.ReprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues=0) -> None
 
-    :param disparity: Input single-channel 16-bit signed or 32-bit floating-point disparity image.
+    :param disparity: Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image.
 
     :param _3dImage: Output 3-channel floating-point image of the same size as  ``disparity`` . Each element of  ``_3dImage(x,y)``  contains 3D coordinates of the point  ``(x,y)``  computed from the disparity map.
 
@@ -1196,11 +1200,11 @@ The method executes the SGBM algorithm on a rectified stereo pair. See ``stereo_
 
 stereoCalibrate
 -------------------
+Calibrates the stereo camera.
+
 .. ocv:function:: double stereoCalibrate( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+                         TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC )
 
-    Calibrates the stereo camera.
-
-.. ocv:pyfunction:: cv2.stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize[, R[, T[, E[, F[, criteria[, flags]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
+.. ocv:pyfunction:: cv2.stereoCalibrate(objectPoints, imagePoints1, imagePoints2, imageSize[, cameraMatrix1[, distCoeffs1[, cameraMatrix2[, distCoeffs2[, R[, T[, E[, F[, criteria[, flags]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
 
 .. ocv:cfunction:: double cvStereoCalibrate( const CvMat* objectPoints, const CvMat* imagePoints1, const CvMat* imagePoints2, const CvMat* pointCounts, CvMat* cameraMatrix1, CvMat* distCoeffs1, CvMat* cameraMatrix2, CvMat* distCoeffs2, CvSize imageSize, CvMat* R, CvMat* T, CvMat* E=0, CvMat* F=0, CvTermCriteria termCrit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, 1e-6), int flags=CV_CALIB_FIX_INTRINSIC )
 .. ocv:pyoldfunction:: cv.StereoCalibrate( objectPoints, imagePoints1, imagePoints2, pointCounts, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E=None, F=None, termCrit=(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, 1e-6), flags=CV_CALIB_FIX_INTRINSIC)-> None
@@ -1211,8 +1215,7 @@ stereoCalibrate
 
     :param imagePoints2: Vector of vectors of the projections of the calibration pattern points, observed by the second camera.
 
-    :param cameraMatrix1: Input/output first camera matrix:  :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` , 
-	:math:`j = 0,\, 1` . If any of  ``CV_CALIB_USE_INTRINSIC_GUESS`` , ``CV_CALIB_FIX_ASPECT_RATIO`` , ``CV_CALIB_FIX_INTRINSIC`` , or  ``CV_CALIB_FIX_FOCAL_LENGTH``  are specified, some or all of the matrix components must be initialized. See the flags description for details.
+    :param cameraMatrix1: Input/output first camera matrix:  :math:`\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}` , :math:`j = 0,\, 1` . If any of  ``CV_CALIB_USE_INTRINSIC_GUESS`` , ``CV_CALIB_FIX_ASPECT_RATIO`` , ``CV_CALIB_FIX_INTRINSIC`` , or  ``CV_CALIB_FIX_FOCAL_LENGTH``  are specified, some or all of the matrix components must be initialized. See the flags description for details.
 
     :param distCoeffs1: Input/output vector of distortion coefficients  :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6]])`  of 4, 5, or 8 elements. The output vector length depends on the flags.
 
@@ -1245,7 +1248,7 @@ stereoCalibrate
             * **CV_CALIB_FIX_ASPECT_RATIO** Optimize :math:`f^{(j)}_y` . Fix the ratio  :math:`f^{(j)}_x/f^{(j)}_y` .
 
             * **CV_CALIB_SAME_FOCAL_LENGTH** Enforce  :math:`f^{(0)}_x=f^{(1)}_x`  and  :math:`f^{(0)}_y=f^{(1)}_y` .
-			
+            
             * **CV_CALIB_ZERO_TANGENT_DIST** Set tangential distortion coefficients for each camera to zeros and fix there.
 
             * **CV_CALIB_FIX_K1,...,CV_CALIB_FIX_K6** Do not change the corresponding radial distortion coefficient during the optimization. If  ``CV_CALIB_USE_INTRINSIC_GUESS``  is set, the coefficient from the supplied  ``distCoeffs``  matrix is used. Otherwise, it is set to 0.
@@ -1287,11 +1290,10 @@ Similarly to :ocv:func:`calibrateCamera` , the function minimizes the total re-p
 
 stereoRectify
 -----------------
+Computes rectification transforms for each head of a calibrated stereo camera.
 
 .. ocv:function:: void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha, Size newImageSize=Size(), Rect* roi1=0, Rect* roi2=0 )
 
-    Computes rectification transforms for each head of a calibrated stereo camera.
-
 .. ocv:cfunction:: void cvStereoRectify( const CvMat* cameraMatrix1, const CvMat* cameraMatrix2, const CvMat* distCoeffs1, const CvMat* distCoeffs2, CvSize imageSize, const CvMat* R, const CvMat* T, CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2, CvMat* Q=0, int flags=CV_CALIB_ZERO_DISPARITY, double alpha=-1, CvSize newImageSize=cvSize(0, 0), CvRect* roi1=0, CvRect* roi2=0)
 .. ocv:pyoldfunction:: cv.StereoRectify( cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q=None, flags=CV_CALIB_ZERO_DISPARITY, alpha=-1, newImageSize=(0, 0))-> (roi1, roi2)
 
@@ -1374,13 +1376,14 @@ See below the screenshot from the ``stereo_calib.cpp`` sample. Some red horizont
 
 stereoRectifyUncalibrated
 -----------------------------
-.. ocv:function:: bool stereoRectifyUncalibrated( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5 )
+Computes a rectification transform for an uncalibrated stereo camera.
 
-    Computes a rectification transform for an uncalibrated stereo camera.
+.. ocv:function:: bool stereoRectifyUncalibrated( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5 )
 
 .. ocv:pyfunction:: cv2.stereoRectifyUncalibrated(points1, points2, F, imgSize[, H1[, H2[, threshold]]]) -> retval, H1, H2
 
 .. ocv:cfunction:: void cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2, const CvMat* F, CvSize imageSize, CvMat* H1, CvMat* H2, double threshold=5 )
+
 .. ocv:pyoldfunction:: cv.StereoRectifyUncalibrated(points1, points2, F, imageSize, H1, H2, threshold=5)-> None
 
     :param points1: Array of feature points in the first image.
@@ -1407,6 +1410,6 @@ The function computes the rectification transformations without knowing intrinsi
 
 .. [BouguetMCT] J.Y.Bouguet. MATLAB calibration tool. http://www.vision.caltech.edu/bouguetj/calib_doc/
 
-.. [Hartley99] Hartley, R.I., “Theory and Practice of Projective Rectification”. IJCV 35 2, pp 115-127 (1999)
+.. [Hartley99] Hartley, R.I., Theory and Practice of Projective Rectification. IJCV 35 2, pp 115-127 (1999)
 
-.. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
\ No newline at end of file
+.. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
diff --git a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp
index 83361bd235..81924805f1 100644
--- a/modules/calib3d/include/opencv2/calib3d/calib3d.hpp
+++ b/modules/calib3d/include/opencv2/calib3d/calib3d.hpp
@@ -120,7 +120,8 @@ CVAPI(void) cvGetOptimalNewCameraMatrix( const CvMat* camera_matrix,
                                          CvSize image_size, double alpha,
                                          CvMat* new_camera_matrix,
                                          CvSize new_imag_size CV_DEFAULT(cvSize(0,0)),
-                                         CvRect* valid_pixel_ROI CV_DEFAULT(0) );
+                                         CvRect* valid_pixel_ROI CV_DEFAULT(0),
+                                         int center_principal_point CV_DEFAULT(0));
 
 /* Converts rotation vector to rotation matrix or vice versa */
 CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst,
@@ -535,6 +536,9 @@ CV_EXPORTS bool findCirclesGrid( InputArray image, Size patternSize,
                                  OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID,
                                  const Ptr<FeatureDetector> &blobDetector = new SimpleBlobDetector());
 
+CV_EXPORTS_W bool findCirclesGridDefault( InputArray image, Size patternSize,
+                                          OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID );
+
 enum
 {
     CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS,
@@ -560,8 +564,8 @@ enum
 CV_EXPORTS_W double calibrateCamera( InputArrayOfArrays objectPoints,
                                      InputArrayOfArrays imagePoints,
                                      Size imageSize,
-                                     CV_IN_OUT InputOutputArray cameraMatrix,
-                                     CV_IN_OUT InputOutputArray distCoeffs,
+                                     CV_OUT InputOutputArray cameraMatrix,
+                                     CV_OUT InputOutputArray distCoeffs,
                                      OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
                                      int flags=0 );
 
@@ -580,10 +584,10 @@ CV_EXPORTS_W void calibrationMatrixValues( InputArray cameraMatrix,
 CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,
                                      InputArrayOfArrays imagePoints1,
                                      InputArrayOfArrays imagePoints2,
-                                     CV_IN_OUT InputOutputArray cameraMatrix1,
-                                     CV_IN_OUT InputOutputArray distCoeffs1,
-                                     CV_IN_OUT InputOutputArray cameraMatrix2,
-                                     CV_IN_OUT InputOutputArray distCoeffs2,
+                                     CV_OUT InputOutputArray cameraMatrix1,
+                                     CV_OUT InputOutputArray distCoeffs1,
+                                     CV_OUT InputOutputArray cameraMatrix2,
+                                     CV_OUT InputOutputArray distCoeffs2,
                                      Size imageSize, OutputArray R,
                                      OutputArray T, OutputArray E, OutputArray F,
                                      TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
@@ -622,7 +626,7 @@ CV_EXPORTS_W float rectify3Collinear( InputArray cameraMatrix1, InputArray distC
 //! returns the optimal new camera matrix
 CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs,
                                             Size imageSize, double alpha, Size newImgSize=Size(),
-                                            CV_OUT Rect* validPixROI=0);
+                                            CV_OUT Rect* validPixROI=0, bool centerPrincipalPoint=false);
 
 //! converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))
 CV_EXPORTS_W void convertPointsToHomogeneous( InputArray src, OutputArray dst );
diff --git a/modules/calib3d/src/calibinit.cpp b/modules/calib3d/src/calibinit.cpp
index 04392a2ba4..362b62f98c 100644
--- a/modules/calib3d/src/calibinit.cpp
+++ b/modules/calib3d/src/calibinit.cpp
@@ -1939,8 +1939,8 @@ void cv::drawChessboardCorners( InputOutputArray _image, Size patternSize,
 bool cv::findCirclesGrid( InputArray _image, Size patternSize,
                           OutputArray _centers, int flags, const Ptr<FeatureDetector> &blobDetector )
 {
-	bool isAsymmetricGrid = (flags & CALIB_CB_ASYMMETRIC_GRID) ? true : false;
-	bool isSymmetricGrid  = (flags & CALIB_CB_SYMMETRIC_GRID ) ? true : false;
+    bool isAsymmetricGrid = (flags & CALIB_CB_ASYMMETRIC_GRID) ? true : false;
+    bool isSymmetricGrid  = (flags & CALIB_CB_SYMMETRIC_GRID ) ? true : false;
     CV_Assert(isAsymmetricGrid ^ isSymmetricGrid);
 
     Mat image = _image.getMat();
diff --git a/modules/calib3d/src/calibration.cpp b/modules/calib3d/src/calibration.cpp
index a35aa7d5bc..43a011f9fe 100644
--- a/modules/calib3d/src/calibration.cpp
+++ b/modules/calib3d/src/calibration.cpp
@@ -2529,46 +2529,81 @@ void cvStereoRectify( const CvMat* _cameraMatrix1, const CvMat* _cameraMatrix2,
 void cvGetOptimalNewCameraMatrix( const CvMat* cameraMatrix, const CvMat* distCoeffs,
                                   CvSize imgSize, double alpha,
                                   CvMat* newCameraMatrix, CvSize newImgSize,
-                                  CvRect* validPixROI )
+                                  CvRect* validPixROI, int centerPrincipalPoint )
 {
     cv::Rect_<float> inner, outer;
-    icvGetRectangles( cameraMatrix, distCoeffs, 0, cameraMatrix, imgSize, inner, outer );
-
     newImgSize = newImgSize.width*newImgSize.height != 0 ? newImgSize : imgSize;
 
     double M[3][3];
     CvMat matM = cvMat(3, 3, CV_64F, M);
     cvConvert(cameraMatrix, &matM);
 
-    double cx0 = M[0][2];
-    double cy0 = M[1][2];
-    double cx = (newImgSize.width-1)*0.5;
-    double cy = (newImgSize.height-1)*0.5;
-
-    double s0 = std::max(std::max(std::max((double)cx/(cx0 - inner.x), (double)cy/(cy0 - inner.y)),
-                        (double)cx/(inner.x + inner.width - cx0)),
-                    (double)cy/(inner.y + inner.height - cy0));
-    double s1 = std::min(std::min(std::min((double)cx/(cx0 - outer.x), (double)cy/(cy0 - outer.y)),
-                        (double)cx/(outer.x + outer.width - cx0)),
-                    (double)cy/(outer.y + outer.height - cy0));
-    double s = s0*(1 - alpha) + s1*alpha;
-
-    M[0][0] *= s;
-    M[1][1] *= s;
-    M[0][2] = cx;
-    M[1][2] = cy;
-    cvConvert(&matM, newCameraMatrix);
-
-    if( validPixROI )
+    if( centerPrincipalPoint )
     {
-        inner = cv::Rect_<float>((float)((inner.x - cx0)*s + cx),
-                             (float)((inner.y - cy0)*s + cy),
-                             (float)(inner.width*s),
-                             (float)(inner.height*s));
-        cv::Rect r(cvCeil(inner.x), cvCeil(inner.y), cvFloor(inner.width), cvFloor(inner.height));
-        r &= cv::Rect(0, 0, newImgSize.width, newImgSize.height);
-        *validPixROI = r;
+        double cx0 = M[0][2];
+        double cy0 = M[1][2];
+        double cx = (newImgSize.width-1)*0.5;
+        double cy = (newImgSize.height-1)*0.5;
+
+        icvGetRectangles( cameraMatrix, distCoeffs, 0, cameraMatrix, imgSize, inner, outer );
+        double s0 = std::max(std::max(std::max((double)cx/(cx0 - inner.x), (double)cy/(cy0 - inner.y)),
+                                      (double)cx/(inner.x + inner.width - cx0)),
+                             (double)cy/(inner.y + inner.height - cy0));
+        double s1 = std::min(std::min(std::min((double)cx/(cx0 - outer.x), (double)cy/(cy0 - outer.y)),
+                                      (double)cx/(outer.x + outer.width - cx0)),
+                             (double)cy/(outer.y + outer.height - cy0));
+        double s = s0*(1 - alpha) + s1*alpha;
+
+        M[0][0] *= s;
+        M[1][1] *= s;
+        M[0][2] = cx;
+        M[1][2] = cy;
+
+        if( validPixROI )
+        {
+            inner = cv::Rect_<float>((float)((inner.x - cx0)*s + cx),
+                                     (float)((inner.y - cy0)*s + cy),
+                                     (float)(inner.width*s),
+                                     (float)(inner.height*s));
+            cv::Rect r(cvCeil(inner.x), cvCeil(inner.y), cvFloor(inner.width), cvFloor(inner.height));
+            r &= cv::Rect(0, 0, newImgSize.width, newImgSize.height);
+            *validPixROI = r;
+        }
     }
+    else
+    {
+        // Get inscribed and circumscribed rectangles in normalized
+        // (independent of camera matrix) coordinates
+        icvGetRectangles( cameraMatrix, distCoeffs, 0, 0, imgSize, inner, outer );
+
+        // Projection mapping inner rectangle to viewport
+        double fx0 = (newImgSize.width  - 1) / inner.width;
+        double fy0 = (newImgSize.height - 1) / inner.height;
+        double cx0 = -fx0 * inner.x;
+        double cy0 = -fy0 * inner.y;
+
+        // Projection mapping outer rectangle to viewport
+        double fx1 = (newImgSize.width  - 1) / outer.width;
+        double fy1 = (newImgSize.height - 1) / outer.height;
+        double cx1 = -fx1 * outer.x;
+        double cy1 = -fy1 * outer.y;
+
+        // Interpolate between the two optimal projections
+        M[0][0] = fx0*(1 - alpha) + fx1*alpha;
+        M[1][1] = fy0*(1 - alpha) + fy1*alpha;
+        M[0][2] = cx0*(1 - alpha) + cx1*alpha;
+        M[1][2] = cy0*(1 - alpha) + cy1*alpha;
+
+        if( validPixROI )
+        {
+            icvGetRectangles( cameraMatrix, distCoeffs, 0, newCameraMatrix, imgSize, inner, outer );
+            cv::Rect r = inner;
+            r &= cv::Rect(0, 0, newImgSize.width, newImgSize.height);
+            *validPixROI = r;
+        }
+    }
+
+    cvConvert(&matM, newCameraMatrix);
 }
 
 
@@ -3374,16 +3409,28 @@ double cv::calibrateCamera( InputArrayOfArrays _objectPoints,
     double reprojErr = cvCalibrateCamera2(&c_objPt, &c_imgPt, &c_npoints, imageSize,
                                           &c_cameraMatrix, &c_distCoeffs, &c_rvecM,
                                           &c_tvecM, flags );
-    _rvecs.create((int)nimages, 1, CV_64FC3);
-    _tvecs.create((int)nimages, 1, CV_64FC3);
+    
+    bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed();
+    
+    if( rvecs_needed )
+        _rvecs.create((int)nimages, 1, CV_64FC3);
+    if( tvecs_needed )
+        _tvecs.create((int)nimages, 1, CV_64FC3);
 
     for( i = 0; i < (int)nimages; i++ )
     {
-        _rvecs.create(3, 1, CV_64F, i, true);
-        _tvecs.create(3, 1, CV_64F, i, true);
-        Mat rv = _rvecs.getMat(i), tv = _tvecs.getMat(i);
-        memcpy(rv.data, rvecM.ptr<double>(i), 3*sizeof(double));
-        memcpy(tv.data, tvecM.ptr<double>(i), 3*sizeof(double));
+        if( rvecs_needed )
+        {
+            _rvecs.create(3, 1, CV_64F, i, true);
+            Mat rv = _rvecs.getMat(i);
+            memcpy(rv.data, rvecM.ptr<double>(i), 3*sizeof(double));
+        }
+        if( tvecs_needed )
+        {
+            _tvecs.create(3, 1, CV_64F, i, true);
+            Mat tv = _tvecs.getMat(i);
+            memcpy(tv.data, tvecM.ptr<double>(i), 3*sizeof(double));
+        }
     }
     cameraMatrix.copyTo(_cameraMatrix);
     distCoeffs.copyTo(_distCoeffs);
@@ -3520,7 +3567,7 @@ bool cv::stereoRectifyUncalibrated( InputArray _points1, InputArray _points2,
 cv::Mat cv::getOptimalNewCameraMatrix( InputArray _cameraMatrix,
                                        InputArray _distCoeffs,
                                        Size imgSize, double alpha, Size newImgSize,
-                                       Rect* validPixROI )
+                                       Rect* validPixROI, bool centerPrincipalPoint )
 {
     Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
     CvMat c_cameraMatrix = cameraMatrix, c_distCoeffs = distCoeffs;
@@ -3530,7 +3577,7 @@ cv::Mat cv::getOptimalNewCameraMatrix( InputArray _cameraMatrix,
     
     cvGetOptimalNewCameraMatrix(&c_cameraMatrix, &c_distCoeffs, imgSize,
                                 alpha, &c_newCameraMatrix,
-                                newImgSize, (CvRect*)validPixROI);
+                                newImgSize, (CvRect*)validPixROI, (int)centerPrincipalPoint);
     return newCameraMatrix;
 }
 
diff --git a/modules/calib3d/src/circlesgrid.cpp b/modules/calib3d/src/circlesgrid.cpp
index 3982bf1a5d..be283ca091 100644
--- a/modules/calib3d/src/circlesgrid.cpp
+++ b/modules/calib3d/src/circlesgrid.cpp
@@ -52,11 +52,12 @@ using namespace std;
 
 void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSize, vector<Point2f> &patternPoints)
 {
-  Mat dists(points.size(), points.size(), CV_32FC1, Scalar(0));
+  int i, j, n = (int)points.size();
+  Mat dists(n, n, CV_32FC1, Scalar(0));
   Mat distsMask(dists.size(), CV_8UC1, Scalar(0));
-  for(size_t i=0; i<points.size(); i++)
+  for(i = 0; i < n; i++)
   {
-    for(size_t j=i+1; j<points.size(); j++)
+    for(j = i+1; j < n; j++)
     {
       dists.at<float>(i, j) = (float)norm(points[i] - points[j]);
       distsMask.at<uchar>(i, j) = 255;
@@ -184,10 +185,11 @@ void CirclesGridClusterFinder::findOutsideCorners(const std::vector<cv::Point2f>
   double min1 = std::numeric_limits<double>::max();
   double min2 = std::numeric_limits<double>::max();
   Point minLoc1, minLoc2;
+  int i, j, n = (int)corners.size();
 
-  for(size_t i=0; i<corners.size(); i++)
+  for(i = 0; i < n; i++)
   {
-    for(size_t j=i+1; j<corners.size(); j++)
+    for(j = i+1; j < n; j++)
     {
       double dist = norm(corners[i] - corners[j]);
       Point loc(j, i);
@@ -209,7 +211,7 @@ void CirclesGridClusterFinder::findOutsideCorners(const std::vector<cv::Point2f>
     }
   }
   std::set<int> outsideCornersIndices;
-  for(size_t i=0; i<corners.size(); i++)
+  for(i = 0; i < n; i++)
   {
     outsideCornersIndices.insert(i);
   }
@@ -417,16 +419,16 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
 {
   const int edgeWeight = 1;
 
-  const size_t n = getVerticesCount();
+  const int n = (int)getVerticesCount();
   distanceMatrix.create(n, n, CV_32SC1);
   distanceMatrix.setTo(infinity);
   for (Vertices::const_iterator it1 = vertices.begin(); it1 != vertices.end(); it1++)
   {
-    distanceMatrix.at<int> (it1->first, it1->first) = 0;
+    distanceMatrix.at<int> ((int)it1->first, (int)it1->first) = 0;
     for (Neighbors::const_iterator it2 = it1->second.neighbors.begin(); it2 != it1->second.neighbors.end(); it2++)
     {
       assert( it1->first != *it2 );
-      distanceMatrix.at<int> (it1->first, *it2) = edgeWeight;
+      distanceMatrix.at<int> ((int)it1->first, (int)*it2) = edgeWeight;
     }
   }
 
@@ -436,17 +438,17 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
     {
       for (Vertices::const_iterator it3 = vertices.begin(); it3 != vertices.end(); it3++)
       {
-        int val1 = distanceMatrix.at<int> (it2->first, it3->first);
+	    int i1 = (int)it1->first, i2 = (int)it2->first, i3 = (int)it3->first;
+        int val1 = distanceMatrix.at<int> (i2, i3);
         int val2;
-        if (distanceMatrix.at<int> (it2->first, it1->first) == infinity || distanceMatrix.at<int> (it1->first,
-                                                                                                   it3->first)
-            == infinity)
+        if (distanceMatrix.at<int> (i2, i1) == infinity ||
+			distanceMatrix.at<int> (i1, i3) == infinity)
           val2 = val1;
         else
         {
-          val2 = distanceMatrix.at<int> (it2->first, it1->first) + distanceMatrix.at<int> (it1->first, it3->first);
+          val2 = distanceMatrix.at<int> (i2, i1) + distanceMatrix.at<int> (i1, i3);
         }
-        distanceMatrix.at<int> (it2->first, it3->first) = (val1 == infinity) ? val2 : std::min(val1, val2);
+        distanceMatrix.at<int> (i2, i3) = (val1 == infinity) ? val2 : std::min(val1, val2);
       }
     }
   }
@@ -748,7 +750,13 @@ Mat CirclesGridFinder::rectifyGrid(Size detectedGridSize, const vector<Point2f>&
   const Point2f offset(150, 150);
 
   vector<Point2f> dstPoints;
-  for (int i = 0; i < detectedGridSize.height; i++)
+  bool isClockwiseBefore =
+      getDirection(centers[0], centers[detectedGridSize.width - 1], centers[centers.size() - 1]) < 0;
+
+  int iStart = isClockwiseBefore ? 0 : detectedGridSize.height - 1;
+  int iEnd = isClockwiseBefore ? detectedGridSize.height : -1;
+  int iStep = isClockwiseBefore ? 1 : -1;
+  for (int i = iStart; i != iEnd; i += iStep)
   {
     for (int j = 0; j < detectedGridSize.width; j++)
     {
@@ -1039,7 +1047,7 @@ void CirclesGridFinder::findBasis(const vector<Point2f> &samples, vector<Point2f
     CV_Error(0, "degenerate basis" );
 
   vector<vector<Point2f> > clusters(2), hulls(2);
-  for (size_t k = 0; k < samples.size(); k++)
+  for (int k = 0; k < (int)samples.size(); k++)
   {
     int label = bestLabels.at<int> (k, 0);
     int idx = -1;
@@ -1150,13 +1158,13 @@ void computePredecessorMatrix(const Mat &dm, int verticesCount, Mat &predecessor
 
 void computeShortestPath(Mat &predecessorMatrix, size_t v1, size_t v2, vector<size_t> &path)
 {
-  if (predecessorMatrix.at<int> (v1, v2) < 0)
+  if (predecessorMatrix.at<int> ((int)v1, (int)v2) < 0)
   {
     path.push_back(v1);
     return;
   }
 
-  computeShortestPath(predecessorMatrix, v1, predecessorMatrix.at<int> (v1, v2), path);
+  computeShortestPath(predecessorMatrix, v1, predecessorMatrix.at<int> ((int)v1, (int)v2), path);
   path.push_back(v2);
 }
 
@@ -1173,7 +1181,7 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
     Mat distanceMatrix;
     g.floydWarshall(distanceMatrix, infinity);
     Mat predecessorMatrix;
-    computePredecessorMatrix(distanceMatrix, g.getVerticesCount(), predecessorMatrix);
+    computePredecessorMatrix(distanceMatrix, (int)g.getVerticesCount(), predecessorMatrix);
 
     double maxVal;
     Point maxLoc;
@@ -1197,9 +1205,9 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
       longestPaths.push_back(path);
 
       int conf = 0;
-      for (size_t v2 = 0; v2 < path.vertices.size(); v2++)
+      for (int v2 = 0; v2 < (int)path.vertices.size(); v2++)
       {
-        conf += basisGraphs[1 - (int)graphIdx].getDegree(v2);
+        conf += (int)basisGraphs[1 - (int)graphIdx].getDegree(v2);
       }
       confidences.push_back(conf);
     }
@@ -1209,7 +1217,7 @@ size_t CirclesGridFinder::findLongestPath(vector<Graph> &basisGraphs, Path &best
 
   int maxConf = -1;
   int bestPathIdx = -1;
-  for (size_t i = 0; i < confidences.size(); i++)
+  for (int i = 0; i < (int)confidences.size(); i++)
   {
     if (confidences[i] > maxConf)
     {
@@ -1235,7 +1243,7 @@ void CirclesGridFinder::drawBasis(const vector<Point2f> &basis, Point2f origin,
   for (size_t i = 0; i < basis.size(); i++)
   {
     Point2f pt(basis[i]);
-    line(drawImg, origin, origin + pt, Scalar(0, i * 255, 0), 2);
+    line(drawImg, origin, origin + pt, Scalar(0, (double)(i * 255), 0), 2);
   }
 }
 
@@ -1312,7 +1320,7 @@ Size CirclesGridFinder::getDetectedGridSize() const
   if (holes.size() == 0)
     return Size(0, 0);
 
-  return Size(holes[0].size(), holes.size());
+  return Size((int)holes[0].size(), (int)holes.size());
 }
 
 void CirclesGridFinder::getHoles(vector<Point2f> &outHoles) const
@@ -1405,8 +1413,8 @@ void CirclesGridFinder::getCornerSegments(const vector<vector<size_t> > &points,
   cornerIndices.clear();
   firstSteps.clear();
   secondSteps.clear();
-  size_t h = points.size();
-  size_t w = points[0].size();
+  int h = (int)points.size();
+  int w = (int)points[0].size();
   CV_Assert(h >= 2 && w >= 2)
     ;
 
@@ -1453,6 +1461,10 @@ void CirclesGridFinder::getCornerSegments(const vector<vector<size_t> > &points,
     cout << "Corners are counterclockwise" << endl;
 #endif
     std::reverse(segments.begin(), segments.end());
+    std::reverse(cornerIndices.begin(), cornerIndices.end());
+    std::reverse(firstSteps.begin(), firstSteps.end());
+    std::reverse(secondSteps.begin(), secondSteps.end());
+    std::swap(firstSteps, secondSteps);
   }
 }
 
@@ -1514,3 +1526,10 @@ size_t CirclesGridFinder::getFirstCorner(vector<Point> &largeCornerIndices, vect
 
   return cornerIdx;
 }
+
+bool cv::findCirclesGridDefault( InputArray image, Size patternSize,
+                             OutputArray centers, int flags )
+{
+    return findCirclesGrid(image, patternSize, centers, flags);
+}
+
diff --git a/modules/calib3d/src/fundam.cpp b/modules/calib3d/src/fundam.cpp
index b289db6046..63f0219498 100644
--- a/modules/calib3d/src/fundam.cpp
+++ b/modules/calib3d/src/fundam.cpp
@@ -84,9 +84,9 @@ int CvHomographyEstimator::runKernel( const CvMat* m1, const CvMat* m2, CvMat* H
     const CvPoint2D64f* M = (const CvPoint2D64f*)m1->data.ptr;
     const CvPoint2D64f* m = (const CvPoint2D64f*)m2->data.ptr;
 
-    double LtL[9][9], W[9][9], V[9][9];
+    double LtL[9][9], W[9][1], V[9][9];
     CvMat _LtL = cvMat( 9, 9, CV_64F, LtL );
-    CvMat matW = cvMat( 9, 9, CV_64F, W );
+    CvMat matW = cvMat( 9, 1, CV_64F, W );
     CvMat matV = cvMat( 9, 9, CV_64F, V );
     CvMat _H0 = cvMat( 3, 3, CV_64F, V[8] );
     CvMat _Htemp = cvMat( 3, 3, CV_64F, V[7] );
@@ -499,15 +499,15 @@ int CvFMEstimator::run8Point( const CvMat* _m1, const CvMat* _m2, CvMat* _fmatri
                 a[j*9+k] += r[j]*r[k];
     }
 
-    cvSVD( &A, &W, 0, &V, CV_SVD_MODIFY_A + CV_SVD_V_T );
+    cvEigenVV(&A, &V, &W);
 
-    for( i = 0; i < 8; i++ )
+    for( i = 0; i < 9; i++ )
     {
         if( fabs(w[i]) < DBL_EPSILON )
             break;
     }
 
-    if( i < 7 )
+    if( i < 8 )
         return 0;
 
     F0 = cvMat( 3, 3, CV_64F, v + 9*8 ); // take the last column of v as a solution of Af = 0
@@ -616,7 +616,7 @@ CV_IMPL int cvFindFundamentalMat( const CvMat* points1, const CvMat* points2,
             (mask->rows == 1 || mask->cols == 1) &&
             mask->rows*mask->cols == count );
     }
-    if( mask || count > 8 )
+    if( mask || count >= 8 )
         tempMask = cvCreateMat( 1, count, CV_8U );
     if( !tempMask.empty() )
         cvSet( tempMask, cvScalarAll(1.) );
@@ -624,9 +624,9 @@ CV_IMPL int cvFindFundamentalMat( const CvMat* points1, const CvMat* points2,
     CvFMEstimator estimator(7);
     if( count == 7 )
         result = estimator.run7Point(m1, m2, &_F9x3);
-    else if( count == 8 || method == CV_FM_8POINT )
+    else if( method == CV_FM_8POINT )
         result = estimator.run8Point(m1, m2, &_F3x3);
-    else if( count >= 8 )
+    else
     {
         if( param1 <= 0 )
             param1 = 3;
diff --git a/modules/calib3d/src/solvepnp.cpp b/modules/calib3d/src/solvepnp.cpp
index 0f43bc6fc4..5ceee9208f 100644
--- a/modules/calib3d/src/solvepnp.cpp
+++ b/modules/calib3d/src/solvepnp.cpp
@@ -132,7 +132,7 @@ namespace cv
                      const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
         {
             Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_32FC3), modelImagePoints(1, MIN_POINTS_COUNT, CV_32FC2);
-            for (size_t i = 0, colIndex = 0; i < pointsMask.size(); i++)
+            for (int i = 0, colIndex = 0; i < (int)pointsMask.size(); i++)
             {
                 if (pointsMask[i])
                 {
@@ -239,8 +239,8 @@ namespace cv
             
             void generateVar(vector<char>& mask) const
             {
-                size_t size = mask.size();
-                for (size_t i = 0; i < size; i++)
+                int size = (int)mask.size();
+                for (int i = 0; i < size; i++)
                 {
                     int i1 = generator.uniform(0, size);
                     int i2 = generator.uniform(0, size);
@@ -302,12 +302,11 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
     
     if (localInliers.size() >= (size_t)pnpransac::MIN_POINTS_COUNT)
     {
-        size_t pointsCount = localInliers.size();
+        int i, pointsCount = (int)localInliers.size();
         Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2);
-        int index;
-        for (size_t i = 0; i < localInliers.size(); i++)
+        for (i = 0; i < pointsCount; i++)
         {
-            index = localInliers[i];
+            int index = localInliers[i];
             Mat colInlierImagePoints = inlierImagePoints(Rect(i, 0, 1, 1));
             imagePoints.col(index).copyTo(colInlierImagePoints);
             Mat colInlierObjectPoints = inlierObjectPoints(Rect(i, 0, 1, 1));
diff --git a/modules/calib3d/src/stereobm.cpp b/modules/calib3d/src/stereobm.cpp
index 8215ef6cb6..354e4fc07c 100644
--- a/modules/calib3d/src/stereobm.cpp
+++ b/modules/calib3d/src/stereobm.cpp
@@ -718,7 +718,7 @@ struct FindStereoCorrespInvoker
         uchar *ptr = state->slidingSumBuf->data.ptr + range.begin() * stripeBufSize;
         int FILTERED = (state->minDisparity - 1)*16;
         
-        Rect roi = validDisparityRect & Rect(0, _row0, cols, _row1);
+        Rect roi = validDisparityRect & Rect(0, _row0, cols, _row1 - _row0);
         if( roi.height == 0 )
             return;
         int row0 = roi.y;
@@ -871,7 +871,6 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
     double N0 = 8000000 / (useShorts ? 1 : 4);  // approx tbb's min number instructions reasonable for one thread    
     double maxStripeSize = min(max(N0 / (width * ndisp), (wsz-1) * SAD_overhead_coeff), (double)height);
     int nstripes = cvCeil(height / maxStripeSize);
-    printf("nstripes=%d\n", nstripes);
 #else
     const int nstripes = 1;
 #endif
diff --git a/modules/calib3d/test/test_fundam.cpp b/modules/calib3d/test/test_fundam.cpp
index 4315ee040b..0ee21f72b1 100644
--- a/modules/calib3d/test/test_fundam.cpp
+++ b/modules/calib3d/test/test_fundam.cpp
@@ -372,7 +372,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
     {
         count = src.rows;
         sdims = src.channels()*src.cols;
-        sstep1 = src.step/sizeof(double);
+        sstep1 = (int)(src.step/sizeof(double));
         sstep2 = 1;
     }
     else
@@ -387,7 +387,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
         else
         {
             sstep1 = 1;
-            sstep2 = src.step/sizeof(double);
+            sstep2 = (int)(src.step/sizeof(double));
         }
     }
 
@@ -395,7 +395,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
     {
         CV_Assert( count == dst.rows );
         ddims = dst.channels()*dst.cols;
-        dstep1 = dst.step/sizeof(double);
+        dstep1 = (int)(dst.step/sizeof(double));
         dstep2 = 1;
     }
     else
@@ -410,7 +410,7 @@ static void test_convertHomogeneous( const Mat& _src, Mat& _dst )
         else
         {
             dstep1 = 1;
-            dstep2 = dst.step/sizeof(double);
+            dstep2 = (int)(dst.step/sizeof(double));
         }
     }
 
diff --git a/modules/contrib/include/opencv2/contrib/contrib.hpp b/modules/contrib/include/opencv2/contrib/contrib.hpp
index 45acfa78e0..ca5c3bc76c 100644
--- a/modules/contrib/include/opencv2/contrib/contrib.hpp
+++ b/modules/contrib/include/opencv2/contrib/contrib.hpp
@@ -568,7 +568,7 @@ namespace cv
     {
     public:
         // Flags	
-        enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_MEDIAN_FILTERING = 8};
+        enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_AUTO_PARAMS = 8, USE_MEDIAN_FILTERING = 16};
         enum {CYCLE_O, CYCLE_V};
         enum {PENALIZATION_TICHONOV, PENALIZATION_CHARBONNIER, PENALIZATION_PERONA_MALIK};
         
@@ -598,7 +598,8 @@ namespace cv
         CV_PROP_RW int		flags;
         
     private:
-        void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level);
+        void autoParams();
+		void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level);
         void VCycle_MyFAS(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
         void VariationalSolver(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
     };
@@ -606,6 +607,7 @@ namespace cv
     CV_EXPORTS void polyfit(const Mat& srcx, const Mat& srcy, Mat& dst, int order);
 }
 
+#include "opencv2/contrib/retina.hpp"
 
 #endif
 
diff --git a/modules/contrib/include/opencv2/contrib/retina.hpp b/modules/contrib/include/opencv2/contrib/retina.hpp
new file mode 100644
index 0000000000..06a3ff8045
--- /dev/null
+++ b/modules/contrib/include/opencv2/contrib/retina.hpp
@@ -0,0 +1,222 @@
+/*#******************************************************************************
+ ** 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.
+ ** 
+ ** 
+ ** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+ ** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+ ** 
+ ** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+ ** 
+ **  Creation - enhancement process 2007-2011
+ **      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+ ** 
+ ** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+ ** Refer to the following research paper for more information:
+ ** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+ ** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+ ** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+ ** 
+ ** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+ ** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+ ** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+ ** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+ ** ====> more informations in the above cited Jeanny Heraults's book.
+ ** 
+ **                          License Agreement
+ **               For Open Source Computer Vision Library
+ ** 
+ ** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ ** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+ ** 
+ **               For Human Visual System tools (hvstools)
+ ** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+ ** 
+ ** Third party copyrights are property of their respective owners.
+ ** 
+ ** Redistribution and use in source and binary forms, with or without modification,
+ ** are permitted provided that the following conditions are met:
+ ** 
+ ** * Redistributions of source code must retain the above copyright notice,
+ **    this list of conditions and the following disclaimer.
+ ** 
+ ** * Redistributions in binary form must reproduce the above copyright notice,
+ **    this list of conditions and the following disclaimer in the documentation
+ **    and/or other materials provided with the distribution.
+ ** 
+ ** * The name of the copyright holders may not be used to endorse or promote products
+ **    derived from this software without specific prior written permission.
+ ** 
+ ** This software is provided by the copyright holders and contributors "as is" and
+ ** any express or implied warranties, including, but not limited to, the implied
+ ** warranties of merchantability and fitness for a particular purpose are disclaimed.
+ ** In no event shall the Intel Corporation or contributors be liable for any direct,
+ ** indirect, incidental, special, exemplary, or consequential damages
+ ** (including, but not limited to, procurement of substitute goods or services;
+ ** loss of use, data, or profits; or business interruption) however caused
+ ** and on any theory of liability, whether in contract, strict liability,
+ ** or tort (including negligence or otherwise) arising in any way out of
+ ** the use of this software, even if advised of the possibility of such damage.
+ *******************************************************************************/
+
+#ifndef __OPENCV_CONTRIB_RETINA_HPP__
+#define __OPENCV_CONTRIB_RETINA_HPP__
+
+/*
+ * Retina.hpp
+ *
+ *  Created on: Jul 19, 2011
+ *      Author: Alexandre Benoit
+ */
+
+#include "opencv2/core/core.hpp" // for all OpenCV core functionalities access, including cv::Exception support
+#include <valarray>
+
+namespace cv
+{
+    
+    enum RETINA_COLORSAMPLINGMETHOD
+    {
+        RETINA_COLOR_RANDOM, /// each pixel position is either R, G or B in a random choice
+        RETINA_COLOR_DIAGONAL,/// color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...
+        RETINA_COLOR_BAYER/// standard bayer sampling
+    };
+    
+    class RetinaFilter;
+    
+    /**
+     * @brief a wrapper class which allows the use of the Gipsa/Listic Labs retina model
+     * @class Retina object is a wrapper class which allows the Gipsa/Listic Labs model to be used.
+     * This retina model allows spatio-temporal image processing (applied on still images, video sequences).
+     * As a summary, these are the retina model properties:
+     * => It applies a spectral whithening (mid-frequency details enhancement)
+     * => high frequency spatio-temporal noise reduction
+     * => low frequency luminance to be reduced (luminance range compression)
+     * => local logarithmic luminance compression allows details to be enhanced in low light conditions
+     *
+     * for more information, reer to the following papers :
+     * Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+     * Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+     */
+    class CV_EXPORTS Retina {
+        
+    public:
+        
+        /**
+         * Main constructor with most commun use setup : create an instance of color ready retina model
+         * @param inputSize : the input frame size
+         */
+        Retina(const std::string parametersSaveFile, Size inputSize);
+        
+        /**
+         * Complete Retina filter constructor which allows all basic structural parameters definition
+         * @param inputSize : the input frame size
+         * @param colorMode : the chosen processing mode : with or without color processing
+         * @param samplingMethod: specifies which kind of color sampling will be used
+         * @param useRetinaLogSampling: activate retina log sampling, if true, the 2 following parameters can be used
+         * @param reductionFactor: only usefull if param useRetinaLogSampling=true, specifies the reduction factor of the output frame (as the center (fovea) is high resolution and corners can be underscaled, then a reduction of the output is allowed without precision leak
+         * @param samplingStrenght: only usefull if param useRetinaLogSampling=true, specifies the strenght of the log scale that is applied
+         */
+        Retina(const std::string parametersSaveFile, Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);
+        
+        virtual ~Retina();
+        
+        /**
+         * try to open an XML retina parameters file to adjust current retina instance setup
+         * => if the xml file does not exist, then default setup is applied
+         * => warning, Exceptions are thrown if read XML file is not valid
+         * @param retinaParameterFile : the parameters filename
+         */
+        void setup(std::string retinaParameterFile="", const bool applyDefaultSetupOnFailure=true);
+        
+        /**
+         * parameters setup display method
+         * @return a string which contains formatted parameters information
+         */
+        const std::string printSetup();
+        
+	    /**
+	     * setup the OPL and IPL parvo channels (see biologocal model)
+	     * OPL is referred as Outer Plexiform Layer of the retina, it allows the spatio-temporal filtering which withens the spectrum and reduces spatio-temporal noise while attenuating global luminance (low frequency energy)
+	     * IPL parvo is the OPL next processing stage, it refers to Inner Plexiform layer of the retina, it allows high contours sensitivity in foveal vision.
+	     * for more informations, please have a look at the paper Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+	     * @param colorMode : specifies if (true) color is processed of not (false) to then processing gray level image
+	     * @param normaliseOutput : specifies if (true) output is rescaled between 0 and 255 of not (false)
+	     * @param photoreceptorsLocalAdaptationSensitivity: the photoreceptors sensitivity renage is 0-1 (more log compression effect when value increases)
+	     * @param photoreceptorsTemporalConstant: the time constant of the first order low pass filter of the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is frames, typical value is 1 frame
+	     * @param photoreceptorsSpatialConstant: the spatial constant of the first order low pass filter of the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is pixels, typical value is 1 pixel
+	     * @param horizontalCellsGain: gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, then, the luminance is not filtered and is still reachable at the output, typicall value is 0
+	     * @param HcellsTemporalConstant: the time constant of the first order low pass filter of the horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is frames, typical value is 1 frame, as the photoreceptors
+	     * @param HcellsSpatialConstant: the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel, this value is also used for local contrast computing when computing the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular channel model)
+	     * @param ganglionCellsSensitivity: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 230
+	     */
+        void setupOPLandIPLParvoChannel(const bool colorMode=true, const bool normaliseOutput = true, const double photoreceptorsLocalAdaptationSensitivity=0.7, const double photoreceptorsTemporalConstant=0.5, const double photoreceptorsSpatialConstant=0.53, const double horizontalCellsGain=0, const double HcellsTemporalConstant=1, const double HcellsSpatialConstant=7, const double ganglionCellsSensitivity=0.7);
+        
+        /**
+         * set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel
+         * this channel processes signals outpint from OPL processing stage in peripheral vision, it allows motion information enhancement. It is decorrelated from the details channel. See reference paper for more details.
+         * @param normaliseOutput : specifies if (true) output is rescaled between 0 and 255 of not (false)
+         * @param parasolCells_beta: the low pass filter gain used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), typical value is 0
+         * @param parasolCells_tau: the low pass filter time constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical value is 0 (immediate response)
+         * @param parasolCells_k: the low pass filter spatial constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical value is 5
+         * @param amacrinCellsTemporalCutFrequency: the time constant of the first order high pass fiter of the magnocellular way (motion information channel), unit is frames, tipicall value is 5
+         * @param V0CompressionParameter: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 200
+         * @param localAdaptintegration_tau: specifies the temporal constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+         * @param localAdaptintegration_k: specifies the spatial constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+         */
+        void setupIPLMagnoChannel(const bool normaliseOutput = true, const double parasolCells_beta=0, const double parasolCells_tau=0, const double parasolCells_k=7, const double amacrinCellsTemporalCutFrequency=1.2, const double V0CompressionParameter=0.95, const double localAdaptintegration_tau=0, const double localAdaptintegration_k=7);
+        /**
+         * method which allows retina to be applied on an input image
+         * @param
+         * 		/// encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods
+         *
+         */
+        void run(const Mat &inputImage);
+        /**
+         * accessor of the details channel of the retina (models foveal vision)
+         * @param retinaOutput_parvo : the output buffer (reallocated if necessary)
+         */
+        void getParvo(Mat &retinaOutput_parvo);
+        
+        /**
+         * accessor of the motion channel of the retina (models peripheral vision)
+         * @param retinaOutput_magno : the output buffer (reallocated if necessary)
+         */
+        void getMagno(Mat &retinaOutput_magno);
+        
+        void clearBuffers();
+        
+    protected:
+        //// Parameteres setup members
+        // parameters file ... saved on instance delete
+        FileStorage _parametersSaveFile;
+        std::string _parametersSaveFileName;
+        //// Retina model related modules
+        // buffer that ensure library cross-compatibility
+        std::valarray<double> _inputBuffer;
+        
+        // pointer to retina model
+        RetinaFilter* _retinaFilter;
+        
+        /**
+         * exports a valarray buffer outing from HVStools objects to a cv::Mat in CV_8UC1 (gray level picture) or CV_8UC3 (color) format
+         * @param grayMatrixToConvert the valarray to export to OpenCV
+         * @param nbRows : the number of rows of the valarray flatten matrix
+         * @param nbColumns : the number of rows of the valarray flatten matrix
+         * @param colorMode : a flag which mentions if matrix is color (true) or graylevel (false)
+         * @param outBuffer : the output matrix which is reallocated to satisfy Retina output buffer dimensions
+         */
+        void _convertValarrayGrayBuffer2cvMat(const std::valarray<double> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, Mat &outBuffer);
+        
+        // private method called by constructirs
+        void _init(const std::string parametersSaveFile, Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);
+        
+        
+    };
+    
+}
+#endif /* __OPENCV_CONTRIB_RETINA_HPP__ */
+
diff --git a/modules/contrib/src/ba.cpp b/modules/contrib/src/ba.cpp
index 0f4cf568de..636ba59c26 100644
--- a/modules/contrib/src/ba.cpp
+++ b/modules/contrib/src/ba.cpp
@@ -995,8 +995,8 @@ void LevMarqSparse::bundleAdjust( vector<Point3d>& points, //positions of points
 				  const TermCriteria& criteria,
 				  BundleAdjustCallback cb, void* user_data) {
   //,enum{MOTION_AND_STRUCTURE,MOTION,STRUCTURE})
-  int num_points = points.size();
-  int num_cameras = cameraMatrix.size();
+  int num_points = (int)points.size();
+  int num_cameras = (int)cameraMatrix.size();
 
   CV_Assert( imagePoints.size() == (size_t)num_cameras && 
 	     visibility.size() == (size_t)num_cameras && 
diff --git a/modules/contrib/src/basicretinafilter.cpp b/modules/contrib/src/basicretinafilter.cpp
new file mode 100644
index 0000000000..f836bcae30
--- /dev/null
+++ b/modules/contrib/src/basicretinafilter.cpp
@@ -0,0 +1,867 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+
+#include <iostream>
+#include <cstdlib>
+#include "basicretinafilter.hpp"
+#include <cmath>
+
+
+namespace cv
+{
+
+// @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+
+//////////////////////////////////////////////////////////
+//                 BASIC RETINA FILTER
+//////////////////////////////////////////////////////////
+
+// Constructor and Desctructor of the basic retina filter
+BasicRetinaFilter::BasicRetinaFilter(const unsigned int NBrows, const unsigned int NBcolumns, const unsigned int parametersListSize, const bool useProgressiveFilter)
+:_filterOutput(NBrows, NBcolumns),
+ _localBuffer(NBrows*NBcolumns),
+ _filteringCoeficientsTable(3*parametersListSize),
+ _progressiveSpatialConstant(0),// pointer to a local table containing local spatial constant (allocated with the object)
+ _progressiveGain(0)
+{
+#ifdef T_BASIC_RETINA_ELEMENT_DEBUG
+	std::cout<<"BasicRetinaFilter::BasicRetinaFilter: new filter, size="<<NBrows<<", "<<NBcolumns<<std::endl;
+#endif
+	_halfNBrows=_filterOutput.getNBrows()/2;
+	_halfNBcolumns=_filterOutput.getNBcolumns()/2;
+
+	if (useProgressiveFilter)
+	{
+#ifdef T_BASIC_RETINA_ELEMENT_DEBUG
+		std::cout<<"BasicRetinaFilter::BasicRetinaFilter: _progressiveSpatialConstant_Tbuffer"<<std::endl;
+#endif
+		_progressiveSpatialConstant.resize(_filterOutput.size());
+#ifdef T_BASIC_RETINA_ELEMENT_DEBUG
+		std::cout<<"BasicRetinaFilter::BasicRetinaFilter: new _progressiveGain_Tbuffer"<<NBrows<<", "<<NBcolumns<<std::endl;
+#endif
+		_progressiveGain.resize(_filterOutput.size());
+	}
+#ifdef T_BASIC_RETINA_ELEMENT_DEBUG
+	std::cout<<"BasicRetinaFilter::BasicRetinaFilter: new filter, size="<<NBrows<<", "<<NBcolumns<<std::endl;
+#endif
+
+	// set default values
+	_maxInputValue=256.0;
+
+	// reset all buffers
+	clearAllBuffers();
+
+#ifdef T_BASIC_RETINA_ELEMENT_DEBUG
+	std::cout<<"BasicRetinaFilter::Init BasicRetinaElement at specified frame size OK, size="<<this->size()<<std::endl;
+#endif
+
+}
+
+BasicRetinaFilter::~BasicRetinaFilter()
+{
+
+#ifdef BASIC_RETINA_ELEMENT_DEBUG
+	std::cout<<"BasicRetinaFilter::BasicRetinaElement Deleted OK"<<std::endl;
+#endif
+
+}
+
+////////////////////////////////////
+// functions of the basic filter
+////////////////////////////////////
+
+
+// resize all allocated buffers
+void BasicRetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+
+	std::cout<<"BasicRetinaFilter::resize( "<<NBrows<<", "<<NBcolumns<<")"<<std::endl;
+
+	// resizing buffers
+	_filterOutput.resizeBuffer(NBrows, NBcolumns);
+
+	// updating variables
+	_halfNBrows=_filterOutput.getNBrows()/2;
+	_halfNBcolumns=_filterOutput.getNBcolumns()/2;
+
+	_localBuffer.resize(_filterOutput.size());
+	// in case of spatial adapted filter
+	if (_progressiveSpatialConstant.size()>0)
+	{
+		_progressiveSpatialConstant.resize(_filterOutput.size());
+		_progressiveGain.resize(_filterOutput.size());
+	}
+	// reset buffers
+	clearAllBuffers();
+}
+
+// Change coefficients table
+void BasicRetinaFilter::setLPfilterParameters(const double beta, const double tau, const double desired_k, const unsigned int filterIndex)
+{
+	double _beta = beta+tau;
+	double k=desired_k;
+	// check if the spatial constant is correct (avoid 0 value to avoid division by 0)
+	if (desired_k<=0)
+	{
+		k=0.001;
+		std::cerr<<"BasicRetinaFilter::spatial constant of the low pass filter must be superior to zero !!! correcting parameter setting to 0,001"<<std::endl;
+	}
+
+	double _alpha = k*k;
+	double _mu = 0.8;
+	unsigned int tableOffset=filterIndex*3;
+	if (k<=0)
+	{
+		std::cerr<<"BasicRetinaFilter::spatial filtering coefficient must be superior to zero, correcting value to 0.01"<<std::endl;
+		_alpha=0.0001;
+	}
+
+	double _temp =  (1.0+_beta)/(2.0*_mu*_alpha);
+	double _a = _filteringCoeficientsTable[tableOffset] = 1.0 + _temp - sqrt( (1.0+_temp)*(1.0+_temp) - 1.0);
+	_filteringCoeficientsTable[1+tableOffset]=(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta);
+	_filteringCoeficientsTable[2+tableOffset] =tau;
+
+	//std::cout<<"BasicRetinaFilter::normal:"<<(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta)<<" -> old:"<<(1-_a)*(1-_a)*(1-_a)*(1-_a)/(1+_beta)<<std::endl;
+
+	//std::cout<<"BasicRetinaFilter::_a="<<_a<<", gain="<<_filteringCoeficientsTable[1+tableOffset]<<", tau="<<tau<<std::endl;
+}
+
+void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const double beta, const double tau, const double alpha0, const unsigned int filterIndex)
+{
+	// check if dedicated buffers are already allocated, if not create them
+	if (_progressiveSpatialConstant.size()!=_filterOutput.size())
+	{
+		_progressiveSpatialConstant.resize(_filterOutput.size());
+		_progressiveGain.resize(_filterOutput.size());
+	}
+
+	double _beta = beta+tau;
+	double _mu=0.8;
+	if (alpha0<=0)
+	{
+		std::cerr<<"BasicRetinaFilter::spatial filtering coefficient must be superior to zero, correcting value to 0.01"<<std::endl;
+		//alpha0=0.0001;
+	}
+
+	unsigned int tableOffset=filterIndex*3;
+
+	double _alpha=0.8;
+	double _temp =  (1.0+_beta)/(2.0*_mu*_alpha);
+	double _a=_filteringCoeficientsTable[tableOffset] = 1.0 + _temp - sqrt( (1.0+_temp)*(1.0+_temp) - 1.0);
+	_filteringCoeficientsTable[tableOffset+1]=(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta);
+	_filteringCoeficientsTable[tableOffset+2] =tau;
+
+	double commonFactor=alpha0/sqrt((double)(_halfNBcolumns*_halfNBcolumns+_halfNBrows*_halfNBrows)+1.0);
+	//memset(_progressiveSpatialConstant, 255, _filterOutput.getNBpixels());
+	for (unsigned int idColumn=0;idColumn<_halfNBcolumns; ++idColumn)
+		for (unsigned int idRow=0;idRow<_halfNBrows; ++idRow)
+		{
+			// computing local spatial constant
+			double localSpatialConstantValue=commonFactor*sqrt((double)(idColumn*idColumn)+(double)(idRow*idRow));
+			if (localSpatialConstantValue>1)
+				localSpatialConstantValue=1;
+
+			_progressiveSpatialConstant[_halfNBcolumns-1+idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1+idRow)]=localSpatialConstantValue;
+			_progressiveSpatialConstant[_halfNBcolumns-1-idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1+idRow)]=localSpatialConstantValue;
+			_progressiveSpatialConstant[_halfNBcolumns-1+idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1-idRow)]=localSpatialConstantValue;
+			_progressiveSpatialConstant[_halfNBcolumns-1-idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1-idRow)]=localSpatialConstantValue;
+
+			// computing local gain
+			double localGain=(1-localSpatialConstantValue)*(1-localSpatialConstantValue)*(1-localSpatialConstantValue)*(1-localSpatialConstantValue)/(1+_beta);
+			_progressiveGain[_halfNBcolumns-1+idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1+idRow)]=localGain;
+			_progressiveGain[_halfNBcolumns-1-idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1+idRow)]=localGain;
+			_progressiveGain[_halfNBcolumns-1+idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1-idRow)]=localGain;
+			_progressiveGain[_halfNBcolumns-1-idColumn+_filterOutput.getNBcolumns()*(_halfNBrows-1-idRow)]=localGain;
+
+			//std::cout<<commonFactor<<", "<<sqrt((_halfNBcolumns-1-idColumn)+(_halfNBrows-idRow-1))<<", "<<(_halfNBcolumns-1-idColumn)<<", "<<(_halfNBrows-idRow-1)<<", "<<localSpatialConstantValue<<std::endl;
+		}
+}
+
+void BasicRetinaFilter::setProgressiveFilterConstants_CustomAccuracy(const double beta, const double tau, const double k, const std::valarray<double> &accuracyMap, const unsigned int filterIndex)
+{
+
+	if (accuracyMap.size()!=_filterOutput.size())
+	{
+		std::cerr<<"BasicRetinaFilter::setProgressiveFilterConstants_CustomAccuracy: error: input accuracy map does not match filter size, init skept"<<std::endl;
+		return ;
+	}
+
+	// check if dedicated buffers are already allocated, if not create them
+	if (_progressiveSpatialConstant.size()!=_filterOutput.size())
+	{
+		_progressiveSpatialConstant.resize(accuracyMap.size());
+		_progressiveGain.resize(accuracyMap.size());
+	}
+
+	double _beta = beta+tau;
+	double _alpha=k*k;
+	double _mu=0.8;
+	if (k<=0)
+	{
+		std::cerr<<"BasicRetinaFilter::spatial filtering coefficient must be superior to zero, correcting value to 0.01"<<std::endl;
+		//alpha0=0.0001;
+	}
+	unsigned int tableOffset=filterIndex*3;
+	double _temp =  (1.0+_beta)/(2.0*_mu*_alpha);
+	double _a=_filteringCoeficientsTable[tableOffset] = 1.0 + _temp - sqrt( (1.0+_temp)*(1.0+_temp) - 1.0);
+	_filteringCoeficientsTable[tableOffset+1]=(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta);
+	_filteringCoeficientsTable[tableOffset+2] =tau;
+
+	//memset(_progressiveSpatialConstant, 255, _filterOutput.getNBpixels());
+	for (unsigned int idColumn=0;idColumn<_filterOutput.getNBcolumns(); ++idColumn)
+		for (unsigned int idRow=0;idRow<_filterOutput.getNBrows(); ++idRow)
+		{
+			// computing local spatial constant
+			unsigned int index=idColumn+idRow*_filterOutput.getNBcolumns();
+			double localSpatialConstantValue=_a*accuracyMap[index];
+			if (localSpatialConstantValue>1)
+				localSpatialConstantValue=1;
+
+			_progressiveSpatialConstant[index]=localSpatialConstantValue;
+
+			// computing local gain
+			double localGain=(1-localSpatialConstantValue)*(1-localSpatialConstantValue)*(1-localSpatialConstantValue)*(1-localSpatialConstantValue)/(1+_beta);
+			_progressiveGain[index]=localGain;
+
+			//std::cout<<commonFactor<<", "<<sqrt((_halfNBcolumns-1-idColumn)+(_halfNBrows-idRow-1))<<", "<<(_halfNBcolumns-1-idColumn)<<", "<<(_halfNBrows-idRow-1)<<", "<<localSpatialConstantValue<<std::endl;
+		}
+}
+
+///////////////////////////////////////////////////////////////////////
+/// Local luminance adaptation functions
+// run local adaptation filter and save result in _filterOutput
+const std::valarray<double> &BasicRetinaFilter::runFilter_LocalAdapdation(const std::valarray<double> &inputFrame, const std::valarray<double> &localLuminance)
+{
+	_localLuminanceAdaptation(get_data(inputFrame), get_data(localLuminance), &_filterOutput[0]);
+	return _filterOutput;
+}
+// run local adaptation filter at a specific output adress
+void BasicRetinaFilter::runFilter_LocalAdapdation(const std::valarray<double> &inputFrame, const std::valarray<double> &localLuminance, std::valarray<double> &outputFrame)
+{
+	_localLuminanceAdaptation(get_data(inputFrame), get_data(localLuminance), &outputFrame[0]);
+}
+// run local adaptation filter and save result in _filterOutput with autonomous low pass filtering before adaptation
+const std::valarray<double> &BasicRetinaFilter::runFilter_LocalAdapdation_autonomous(const std::valarray<double> &inputFrame)
+{
+	_spatiotemporalLPfilter(get_data(inputFrame), &_filterOutput[0]);
+	_localLuminanceAdaptation(get_data(inputFrame), &_filterOutput[0], &_filterOutput[0]);
+	return _filterOutput;
+}
+// run local adaptation filter at a specific output adress with autonomous low pass filtering before adaptation
+void BasicRetinaFilter::runFilter_LocalAdapdation_autonomous(const std::valarray<double> &inputFrame, std::valarray<double> &outputFrame)
+{
+	_spatiotemporalLPfilter(get_data(inputFrame), &_filterOutput[0]);
+	_localLuminanceAdaptation(get_data(inputFrame), &_filterOutput[0], &outputFrame[0]);
+}
+// local luminance adaptation of the input in regard of localLuminance buffer
+void BasicRetinaFilter::_localLuminanceAdaptation(const double *inputFrame, const double *localLuminance, double *outputFrame)
+{
+	double meanLuminance=0;
+	const double *luminancePTR=inputFrame;
+	for (unsigned int i=0;i<_filterOutput.getNBpixels();++i)
+		meanLuminance+=*(luminancePTR++);
+	meanLuminance/=_filterOutput.getNBpixels();
+	//double tempMeanValue=meanLuminance+_meanInputValue*_tau;
+
+	updateCompressionParameter(meanLuminance);
+	//std::cout<<meanLuminance<<std::endl;
+	const double *localLuminancePTR=localLuminance;
+	const double *inputFramePTR=inputFrame;
+	double *outputFramePTR=outputFrame;
+	for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR)
+	{
+		double X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
+		*(outputFramePTR++) = (_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0);
+		//std::cout<<"BasicRetinaFilter::inputFrame[IDpixel]=%f, X0=%f, outputFrame[IDpixel]=%f\n", inputFrame[IDpixel], X0, outputFrame[IDpixel]);
+	}
+}
+
+// local adaptation applied on a range of values which can be positive and negative
+void BasicRetinaFilter::_localLuminanceAdaptationPosNegValues(const double *inputFrame, const double *localLuminance, double *outputFrame)
+{
+	const double *localLuminancePTR=localLuminance;
+	const double *inputFramePTR=inputFrame;
+	double *outputFramePTR=outputFrame;
+	double factor=_maxInputValue*2/CV_PI;
+	for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputFramePTR)
+	{
+		double X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
+		*(outputFramePTR++) = factor*atan(*inputFramePTR/X0);//(_maxInputValue+X0)**inputFramePTR/(*inputFramePTR +X0);
+		//std::cout<<"BasicRetinaFilter::inputFrame[IDpixel]=%f, X0=%f, outputFrame[IDpixel]=%f\n", inputFrame[IDpixel], X0, outputFrame[IDpixel]);
+	}
+}
+
+// local luminance adaptation of the input in regard of localLuminance buffer, the input is rewrited and becomes the output
+void BasicRetinaFilter::_localLuminanceAdaptation(double *inputOutputFrame, const double *localLuminance)
+{
+	/*double meanLuminance=0;
+    const double *luminancePTR=inputOutputFrame;
+    for (unsigned int i=0;i<_filterOutput.getNBpixels();++i)
+      meanLuminance+=*(luminancePTR++);
+    meanLuminance/=_filterOutput.getNBpixels();
+    //double tempMeanValue=meanLuminance+_meanInputValue*_tau;
+
+    updateCompressionParameter(meanLuminance);
+	 */
+	const double *localLuminancePTR=localLuminance;
+	double *inputOutputFramePTR=inputOutputFrame;
+
+	for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel, ++inputOutputFramePTR)
+	{
+		double X0=*(localLuminancePTR++)*_localLuminanceFactor+_localLuminanceAddon;
+		*(inputOutputFramePTR) = (_maxInputValue+X0)**inputOutputFramePTR/(*inputOutputFramePTR +X0);
+	}
+}
+///////////////////////////////////////////////////////////////////////
+/// Spatio temporal Low Pass filter functions
+// run LP filter and save result in the basic retina element buffer
+const std::valarray<double> &BasicRetinaFilter::runFilter_LPfilter(const std::valarray<double> &inputFrame, const unsigned int filterIndex)
+{
+	_spatiotemporalLPfilter(get_data(inputFrame), &_filterOutput[0], filterIndex);
+	return _filterOutput;
+}
+
+// run LP filter for a new frame input and save result at a specific output adress
+void BasicRetinaFilter::runFilter_LPfilter(const std::valarray<double> &inputFrame, std::valarray<double> &outputFrame, const unsigned int filterIndex)
+{
+	_spatiotemporalLPfilter(get_data(inputFrame), &outputFrame[0], filterIndex);
+}
+
+// run LP filter on the input data and rewrite it
+void BasicRetinaFilter::runFilter_LPfilter_Autonomous(std::valarray<double> &inputOutputFrame, const unsigned int filterIndex)
+{
+	unsigned int coefTableOffset=filterIndex*3;
+
+	/**********/
+	_a=_filteringCoeficientsTable[coefTableOffset];
+	_gain=_filteringCoeficientsTable[1+coefTableOffset];
+	_tau=_filteringCoeficientsTable[2+coefTableOffset];
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+	_horizontalCausalFilter(&inputOutputFrame[0], 0, _filterOutput.getNBrows());
+	_horizontalAnticausalFilter(&inputOutputFrame[0], 0, _filterOutput.getNBrows());
+	_verticalCausalFilter(&inputOutputFrame[0], 0, _filterOutput.getNBcolumns());
+	_verticalAnticausalFilter_multGain(&inputOutputFrame[0], 0, _filterOutput.getNBcolumns());
+
+}
+// run LP filter for a new frame input and save result at a specific output adress
+void BasicRetinaFilter::_spatiotemporalLPfilter(const double *inputFrame, double *outputFrame, const unsigned int filterIndex)
+{
+	unsigned int coefTableOffset=filterIndex*3;
+	/**********/
+	_a=_filteringCoeficientsTable[coefTableOffset];
+	_gain=_filteringCoeficientsTable[1+coefTableOffset];
+	_tau=_filteringCoeficientsTable[2+coefTableOffset];
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+	_horizontalCausalFilter_addInput(inputFrame, outputFrame, 0,_filterOutput.getNBrows());
+	_horizontalAnticausalFilter(outputFrame, 0, _filterOutput.getNBrows());
+	_verticalCausalFilter(outputFrame, 0, _filterOutput.getNBcolumns());
+	_verticalAnticausalFilter_multGain(outputFrame, 0, _filterOutput.getNBcolumns());
+
+}
+
+// run SQUARING LP filter for a new frame input and save result at a specific output adress
+const double BasicRetinaFilter::_squaringSpatiotemporalLPfilter(const double *inputFrame, double *outputFrame, const unsigned int filterIndex)
+{
+	unsigned int coefTableOffset=filterIndex*3;
+	/**********/
+	_a=_filteringCoeficientsTable[coefTableOffset];
+	_gain=_filteringCoeficientsTable[1+coefTableOffset];
+	_tau=_filteringCoeficientsTable[2+coefTableOffset];
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+
+	_squaringHorizontalCausalFilter(inputFrame, outputFrame, 0, _filterOutput.getNBrows());
+	_horizontalAnticausalFilter(outputFrame, 0, _filterOutput.getNBrows());
+	_verticalCausalFilter(outputFrame, 0, _filterOutput.getNBcolumns());
+	return _verticalAnticausalFilter_returnMeanValue(outputFrame, 0, _filterOutput.getNBcolumns());
+}
+
+/////////////////////////////////////////////////
+// standard version of the 1D low pass filters
+
+//  horizontal causal filter which adds the input inside
+void BasicRetinaFilter::_horizontalCausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+
+
+	//#pragma omp parallel for
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  _a* result;
+			*(outputPTR++) = result;
+		}
+	}
+}
+//  horizontal causal filter which adds the input inside
+void BasicRetinaFilter::_horizontalCausalFilter_addInput(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	//#pragma omp parallel for
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double* outputPTR=outputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
+		register const double* inputPTR=inputFrame+(IDrowStart+IDrow)*_filterOutput.getNBcolumns();
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(inputPTR++) + _tau**(outputPTR)+  _a* result;
+			*(outputPTR++) = result;
+		}
+	}
+
+}
+
+//  horizontal anticausal filter  (basic way, no add on)
+void BasicRetinaFilter::_horizontalAnticausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+
+	//#pragma omp parallel for
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1;
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  _a* result;
+			*(outputPTR--) = result;
+		}
+	}
+
+
+}
+//  horizontal anticausal filter which multiplies the output by _gain
+void BasicRetinaFilter::_horizontalAnticausalFilter_multGain(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+
+	//#pragma omp parallel for
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double* outputPTR=outputFrame+(IDrowEnd-IDrow)*(_filterOutput.getNBcolumns())-1;
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  _a* result;
+			*(outputPTR--) = _gain*result;
+		}
+	}
+}
+
+//  vertical anticausal filter
+void BasicRetinaFilter::_verticalCausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	//#pragma omp parallel for
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputFrame+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + _a * result;
+			*(outputPTR) = result;
+			outputPTR+=_filterOutput.getNBcolumns();
+
+		}
+	}
+}
+
+
+//  vertical anticausal filter (basic way, no add on)
+void BasicRetinaFilter::_verticalAnticausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	double* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	//#pragma omp parallel for
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=offset+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + _a * result;
+			*(outputPTR) = result;
+			outputPTR-=_filterOutput.getNBcolumns();
+
+		}
+	}
+}
+
+//  vertical anticausal filter which multiplies the output by _gain
+void BasicRetinaFilter::_verticalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	double* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	//#pragma omp parallel for
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=offset+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + _a * result;
+			*(outputPTR) = _gain*result;
+			outputPTR-=_filterOutput.getNBcolumns();
+
+		}
+	}
+
+}
+
+/////////////////////////////////////////
+// specific modifications of 1D filters
+
+// -> squaring horizontal causal filter
+void BasicRetinaFilter::_squaringHorizontalCausalFilter(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(inputPTR)**(inputPTR) + _tau**(outputPTR)+  _a* result;
+			*(outputPTR++) = result;
+			++inputPTR;
+		}
+	}
+}
+
+//  vertical anticausal filter that returns the mean value of its result
+const double BasicRetinaFilter::_verticalAnticausalFilter_returnMeanValue(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	register double meanValue=0;
+	double* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=offset+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + _a * result;
+			*(outputPTR) = _gain*result;
+			meanValue+=*(outputPTR);
+			outputPTR-=_filterOutput.getNBcolumns();
+
+		}
+	}
+
+	return meanValue/(double)_filterOutput.getNBpixels();
+}
+
+// LP filter with integration in specific areas (regarding true values of a binary parameters image)
+void BasicRetinaFilter::_localSquaringSpatioTemporalLPfilter(const double *inputFrame, double *LPfilterOutput, const unsigned int *integrationAreas, const unsigned int filterIndex)
+{
+	unsigned int coefTableOffset=filterIndex*3;
+	_a=_filteringCoeficientsTable[coefTableOffset+0];
+	_gain=_filteringCoeficientsTable[coefTableOffset+1];
+	_tau=_filteringCoeficientsTable[coefTableOffset+2];
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+
+	_local_squaringHorizontalCausalFilter(inputFrame, LPfilterOutput, 0, _filterOutput.getNBrows(), integrationAreas);
+	_local_horizontalAnticausalFilter(LPfilterOutput, 0, _filterOutput.getNBrows(), integrationAreas);
+	_local_verticalCausalFilter(LPfilterOutput, 0, _filterOutput.getNBcolumns(), integrationAreas);
+	_local_verticalAnticausalFilter_multGain(LPfilterOutput, 0, _filterOutput.getNBcolumns(), integrationAreas);
+
+}
+
+// LP filter on specific parts of the picture instead of all the image
+// same functions (some of them) but take a binary flag to allow integration, false flag means, no data change at the output...
+
+// this function take an image in input and squares it befor computing
+void BasicRetinaFilter::_local_squaringHorizontalCausalFilter(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas)
+{
+	register double* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	const unsigned int *integrationAreasPTR=integrationAreas;
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			if (*(integrationAreasPTR++))
+				result = *(inputPTR)**(inputPTR) + _tau**(outputPTR)+  _a* result;
+			else
+				result=0;
+			*(outputPTR++) = result;
+			++inputPTR;
+
+		}
+	}
+}
+
+void BasicRetinaFilter::_local_horizontalAnticausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas)
+{
+
+	register double* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1;
+	const unsigned int *integrationAreasPTR=integrationAreas;
+
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			if (*(integrationAreasPTR++))
+				result = *(outputPTR)+  _a* result;
+			else
+				result=0;
+			*(outputPTR--) = result;
+		}
+	}
+
+}
+
+void BasicRetinaFilter::_local_verticalCausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd, const unsigned int *integrationAreas)
+{
+	const unsigned int *integrationAreasPTR=integrationAreas;
+
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputFrame+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			if (*(integrationAreasPTR++))
+				result = *(outputPTR)+  _a* result;
+			else
+				result=0;
+			*(outputPTR) = result;
+			outputPTR+=_filterOutput.getNBcolumns();
+
+		}
+	}
+}
+// this functions affects _gain at the output
+void BasicRetinaFilter::_local_verticalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd, const unsigned int *integrationAreas)
+{
+	const unsigned int *integrationAreasPTR=integrationAreas;
+	double* offset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=offset+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			if (*(integrationAreasPTR++))
+				result = *(outputPTR)+  _a* result;
+			else
+				result=0;
+			*(outputPTR) = _gain*result;
+			outputPTR-=_filterOutput.getNBcolumns();
+
+		}
+	}
+}
+
+////////////////////////////////////////////////////
+// run LP filter for a new frame input and save result at a specific output adress
+// -> USE IRREGULAR SPATIAL CONSTANT
+
+// irregular filter computed from a buffer and rewrites it
+void BasicRetinaFilter::_spatiotemporalLPfilter_Irregular(double *inputOutputFrame, const unsigned int filterIndex)
+{
+	if (_progressiveGain.size()==0)
+	{
+		std::cerr<<"BasicRetinaFilter::runProgressiveFilter: cannot perform filtering, no progressive filter settled up"<<std::endl;
+		return;
+	}
+	unsigned int coefTableOffset=filterIndex*3;
+	/**********/
+	//_a=_filteringCoeficientsTable[coefTableOffset];
+	_tau=_filteringCoeficientsTable[2+coefTableOffset];
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+	_horizontalCausalFilter_Irregular(inputOutputFrame, 0, (int)_filterOutput.getNBrows());
+	_horizontalAnticausalFilter_Irregular(inputOutputFrame, 0, (int)_filterOutput.getNBrows());
+	_verticalCausalFilter_Irregular(inputOutputFrame, 0, (int)_filterOutput.getNBcolumns());
+	_verticalAnticausalFilter_Irregular_multGain(inputOutputFrame, 0, (int)_filterOutput.getNBcolumns());
+
+}
+// irregular filter computed from a buffer and puts result on another
+void BasicRetinaFilter::_spatiotemporalLPfilter_Irregular(const double *inputFrame, double *outputFrame, const unsigned int filterIndex)
+{
+	if (_progressiveGain.size()==0)
+	{
+		std::cerr<<"BasicRetinaFilter::runProgressiveFilter: cannot perform filtering, no progressive filter settled up"<<std::endl;
+		return;
+	}
+	unsigned int coefTableOffset=filterIndex*3;
+	/**********/
+	//_a=_filteringCoeficientsTable[coefTableOffset];
+	_tau=_filteringCoeficientsTable[2+coefTableOffset];
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+	_horizontalCausalFilter_Irregular_addInput(inputFrame, outputFrame, 0, (int)_filterOutput.getNBrows());
+	_horizontalAnticausalFilter_Irregular(outputFrame, 0, (int)_filterOutput.getNBrows());
+	_verticalCausalFilter_Irregular(outputFrame, 0, (int)_filterOutput.getNBcolumns());
+	_verticalAnticausalFilter_Irregular_multGain(outputFrame, 0, (int)_filterOutput.getNBcolumns());
+
+}
+// 1D filters with irregular spatial constant
+//  horizontal causal filter wich runs on its input buffer
+void BasicRetinaFilter::_horizontalCausalFilter_Irregular(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns();
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  *(spatialConstantPTR++)* result;
+			*(outputPTR++) = result;
+		}
+	}
+}
+
+// horizontal causal filter with add input
+void BasicRetinaFilter::_horizontalCausalFilter_Irregular_addInput(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowStart*_filterOutput.getNBcolumns();
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(inputPTR++) + _tau**(outputPTR)+  *(spatialConstantPTR++)* result;
+			*(outputPTR++) = result;
+		}
+	}
+
+}
+
+//  horizontal anticausal filter  (basic way, no add on)
+void BasicRetinaFilter::_horizontalAnticausalFilter_Irregular(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1;
+	register const double* spatialConstantPTR=&_progressiveSpatialConstant[0]+IDrowEnd*(_filterOutput.getNBcolumns())-1;
+
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  *(spatialConstantPTR--)* result;
+			*(outputPTR--) = result;
+		}
+	}
+
+
+}
+
+//  vertical anticausal filter
+void BasicRetinaFilter::_verticalCausalFilter_Irregular(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputFrame+IDcolumn;
+		register const double *spatialConstantPTR=&_progressiveSpatialConstant[0]+IDcolumn;
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + *(spatialConstantPTR) * result;
+			*(outputPTR) = result;
+			outputPTR+=_filterOutput.getNBcolumns();
+			spatialConstantPTR+=_filterOutput.getNBcolumns();
+		}
+	}
+}
+
+//  vertical anticausal filter which multiplies the output by _gain
+void BasicRetinaFilter::_verticalAnticausalFilter_Irregular_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	double* outputOffset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	const double* constantOffset=&_progressiveSpatialConstant[0]+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	const double* gainOffset=&_progressiveGain[0]+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputOffset+IDcolumn;
+		register const double *spatialConstantPTR=constantOffset+IDcolumn;
+		register const double *progressiveGainPTR=gainOffset+IDcolumn;
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + *(spatialConstantPTR) * result;
+			*(outputPTR) = *(progressiveGainPTR)*result;
+			outputPTR-=_filterOutput.getNBcolumns();
+			spatialConstantPTR-=_filterOutput.getNBcolumns();
+			progressiveGainPTR-=_filterOutput.getNBcolumns();
+		}
+	}
+
+}
+}
diff --git a/modules/contrib/src/basicretinafilter.hpp b/modules/contrib/src/basicretinafilter.hpp
new file mode 100644
index 0000000000..e13035e709
--- /dev/null
+++ b/modules/contrib/src/basicretinafilter.hpp
@@ -0,0 +1,441 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * The name of the copyright holders may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+** 
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+*******************************************************************************/
+
+#ifndef BASICRETINAELEMENT_HPP_
+#define BASICRETINAELEMENT_HPP_
+
+#include <cstring>
+
+
+/**
+* @class BasicRetinaFilter
+* @brief Brief overview, this class provides tools for low level image processing:
+* --> this class is able to perform:
+* -> first order Low pass optimized filtering
+* -> local luminance adaptation (able to correct back light problems and contrast enhancement)
+* -> progressive low pass filter filtering (higher filtering on the borders than on the center)
+* -> image data between 0 and 255 resampling with different options, linear rescaling, sigmoide)
+*
+* TYPICAL USE:
+*
+* // create object at a specified picture size
+* BasicRetinaFilter *_photoreceptorsPrefilter;
+* _photoreceptorsPrefilter =new BasicRetinaFilter(sizeRows, sizeWindows);
+*
+* // init gain, spatial and temporal parameters:
+* _photoreceptorsPrefilter->setCoefficientsTable(gain,temporalConstant, spatialConstant);
+*
+* // during program execution, call the filter for local luminance correction or low pass filtering for an input picture called "FrameBuffer":
+* _photoreceptorsPrefilter->runFilter_LocalAdapdation(FrameBuffer);
+* // or (Low pass first order filter)
+* _photoreceptorsPrefilter->runFilter_LPfilter(FrameBuffer);
+* // get output frame and its size:
+* const unsigned int output_nbRows=_photoreceptorsPrefilter->getNBrows();
+* const unsigned int output_nbColumns=_photoreceptorsPrefilter->getNBcolumns();
+* const double *outputFrame=_photoreceptorsPrefilter->getOutput();
+*
+* // at the end of the program, destroy object:
+* delete _photoreceptorsPrefilter;
+
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+* synthesis of the work described in Alexandre BENOIT thesis: "Le systeme visuel humain au secours de la vision par ordinateur"
+*/
+
+#include <iostream>
+#include "templatebuffer.hpp"
+
+//#define __BASIC_RETINA_ELEMENT_DEBUG
+
+//using namespace std;
+namespace cv
+{
+class BasicRetinaFilter
+{
+
+public:
+
+	/**
+	* constructor of the base bio-inspired toolbox, parameters are only linked to imae input size and number of filtering capabilities of the object
+	* @param NBrows: number of rows of the input image
+	* @param NBcolumns: number of columns of the input image
+	* @param parametersListSize: specifies the number of parameters set (each parameters set represents a specific low pass spatio-temporal filter)
+	* @param useProgressiveFilter: specifies if the filter has irreguar (progressive) filtering capabilities (this can be activated later using setProgressiveFilterConstants_xxx methods)
+	*/
+	BasicRetinaFilter(const unsigned int NBrows, const unsigned int NBcolumns, const unsigned int parametersListSize=1, const bool useProgressiveFilter=false);
+
+	/**
+	* standrad destructore
+	*/
+	~BasicRetinaFilter();
+
+	/**
+	* function which clears the output buffer of the object
+	*/
+	inline void clearOutputBuffer(){_filterOutput=0;};
+
+	/**
+	* function which clears the secondary buffer of the object
+	*/
+	inline void clearSecondaryBuffer(){_localBuffer=0;};
+
+	/**
+	* function which clears the output and the secondary buffer of the object
+	*/
+	inline void clearAllBuffers(){clearOutputBuffer();clearSecondaryBuffer();};
+
+	/**
+	* resize basic retina filter object (resize all allocated buffers
+	* @param NBrows: the new height size
+	* @param NBcolumns: the new width size
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+	/**
+	* forbiden method inherited from parent std::valarray
+	* prefer not to use this method since the filter matrix become vectors
+	*/
+	void resize(const unsigned int){std::cerr<<"error, not accessible method"<<std::endl;};
+
+	/**
+	*  low pass filter call and run (models the homogeneous cells network at the retina level, for example horizontal cells or photoreceptors)
+	* @param inputFrame: the input image to be processed
+	* @param filterIndex: the offset which specifies the parameter set that should be used for the filtering
+	* @return the processed image, the output is reachable later by using function getOutput()
+	*/
+	const std::valarray<double> &runFilter_LPfilter(const std::valarray<double> &inputFrame, const unsigned int filterIndex=0); // run the LP filter for a new frame input and save result in _filterOutput
+
+	/**
+	* low pass filter call and run (models the homogeneous cells network at the retina level, for example horizontal cells or photoreceptors)
+	* @param inputFrame: the input image to be processed
+	* @param outputFrame: the output buffer in which the result is writed
+	* @param filterIndex: the offset which specifies the parameter set that should be used for the filtering
+	*/
+	void runFilter_LPfilter(const std::valarray<double> &inputFrame, std::valarray<double> &outputFrame, const unsigned int filterIndex=0); // run LP filter on a specific output adress
+
+	/**
+	*  low pass filter call and run (models the homogeneous cells network at the retina level, for example horizontal cells or photoreceptors)
+	* @param inputOutputFrame: the input image to be processed on which the result is rewrited
+	* @param filterIndex: the offset which specifies the parameter set that should be used for the filtering
+	*/
+	void runFilter_LPfilter_Autonomous(std::valarray<double> &inputOutputFrame, const unsigned int filterIndex=0);// run LP filter on the input data and rewrite it
+
+	/**
+	*  local luminance adaptation call and run (contrast enhancement property of the photoreceptors)
+	* @param inputOutputFrame: the input image to be processed
+	* @param localLuminance: an image which represents the local luminance of the inputFrame parameter, in general, it is its low pass spatial filtering
+	* @return the processed image, the output is reachable later by using function getOutput()
+	*/
+	const std::valarray<double> &runFilter_LocalAdapdation(const std::valarray<double> &inputOutputFrame, const std::valarray<double> &localLuminance);// run local adaptation filter and save result in _filterOutput
+
+	/**
+	*  local luminance adaptation call and run (contrast enhancement property of the photoreceptors)
+	* @param inputFrame: the input image to be processed
+	* @param localLuminance: an image which represents the local luminance of the inputFrame parameter, in general, it is its low pass spatial filtering
+	* @param outputFrame: the output buffer in which the result is writed
+	*/
+	void runFilter_LocalAdapdation(const std::valarray<double> &inputFrame, const std::valarray<double> &localLuminance, std::valarray<double> &outputFrame); // run local adaptation filter on a specific output adress
+
+	/**
+	*  local luminance adaptation call and run (contrast enhancement property of the photoreceptors)
+	* @param inputFrame: the input image to be processed
+	* @return the processed image, the output is reachable later by using function getOutput()
+	*/
+	const std::valarray<double> &runFilter_LocalAdapdation_autonomous(const std::valarray<double> &inputFrame);// run local adaptation filter and save result in _filterOutput
+
+	/**
+	*  local luminance adaptation call and run (contrast enhancement property of the photoreceptors)
+	* @param inputFrame: the input image to be processed
+	* @param outputFrame: the output buffer in which the result is writen
+	*/
+	void runFilter_LocalAdapdation_autonomous(const std::valarray<double> &inputFrame, std::valarray<double> &outputFrame); // run local adaptation filter on a specific output adress
+
+	/**
+	* run low pass filtering with progressive parameters (models the retina log sampling of the photoreceptors and its low pass filtering effect consequence: more powerfull low pass filtering effect on the corners)
+	* @param inputFrame: the input image to be processed
+	* @param filterIndex: the index which specifies the parameter set that should be used for the filtering
+	* @return the processed image, the output is reachable later by using function getOutput() if outputFrame is NULL
+	*/
+	inline void runProgressiveFilter(std::valarray<double> &inputFrame, const unsigned int filterIndex=0){_spatiotemporalLPfilter_Irregular(&inputFrame[0], filterIndex);};
+
+	/**
+	* run low pass filtering with progressive parameters (models the retina log sampling of the photoreceptors and its low pass filtering effect consequence: more powerfull low pass filtering effect on the corners)
+	* @param inputFrame: the input image to be processed
+	* @param outputFrame: the output buffer in which the result is writen
+	* @param filterIndex: the index which specifies the parameter set that should be used for the filtering
+	*/
+	inline void runProgressiveFilter(const std::valarray<double> &inputFrame,
+									 std::valarray<double> &outputFrame,
+									 const unsigned int filterIndex=0)
+	{_spatiotemporalLPfilter_Irregular(get_data(inputFrame), &outputFrame[0], filterIndex);};
+
+	/**
+	* first order spatio-temporal low pass filter setup function
+	* @param beta: gain of the filter (generally set to zero)
+	* @param tau: time constant of the filter (unit is frame for video processing)
+	* @param k: spatial constant of the filter (unit is pixels)
+	* @param filterIndex: the index which specifies the parameter set that should be used for the filtering
+	*/
+	void setLPfilterParameters(const double beta, const double tau, const double k, const unsigned int filterIndex=0); // change the parameters of the filter
+
+	/**
+	* first order spatio-temporal low pass filter setup function
+	* @param beta: gain of the filter (generally set to zero)
+	* @param tau: time constant of the filter (unit is frame for video processing)
+	* @param alpha0: spatial constant of the filter (unit is pixels) on the border of the image
+	* @param filterIndex: the index which specifies the parameter set that should be used for the filtering
+	*/
+	void setProgressiveFilterConstants_CentredAccuracy(const double beta, const double tau, const double alpha0, const unsigned int filterIndex=0);
+
+	/**
+	* first order spatio-temporal low pass filter setup function
+	* @param beta: gain of the filter (generally set to zero)
+	* @param tau: time constant of the filter (unit is frame for video processing)
+	* @param alpha0: spatial constant of the filter (unit is pixels) on the border of the image
+	* @param accuracyMap an image (double format) which values range is between 0 and 1, where 0 means, apply no filtering and 1 means apply the filtering as specified in the parameters set, intermediate values allow to smooth variations of the filtering strenght
+	* @param filterIndex: the index which specifies the parameter set that should be used for the filtering
+	*/
+	void setProgressiveFilterConstants_CustomAccuracy(const double beta, const double tau, const double alpha0, const std::valarray<double> &accuracyMap, const unsigned int filterIndex=0);
+
+	/**
+	* local luminance adaptation setup, this function should be applied for normal local adaptation (not for tone mapping operation)
+	* @param v0: compression effect for the local luminance adaptation processing, set a value between 0.6 and 0.9 for best results, a high value yields to a high compression effect
+	* @param maxInputValue: the maximum amplitude value measured after local adaptation processing (c.f. function runFilter_LocalAdapdation & runFilter_LocalAdapdation_autonomous)
+	* @param meanLuminance: the a priori meann luminance of the input data (should be 128 for 8bits images but can vary greatly in case of High Dynamic Range Images (HDRI)
+	*/
+	void setV0CompressionParameter(const double v0, const double maxInputValue, const double){ _v0=v0*maxInputValue; _localLuminanceFactor=v0; _localLuminanceAddon=maxInputValue*(1.0-v0); _maxInputValue=maxInputValue;};
+
+	/**
+	* update local luminance adaptation setup, initial maxInputValue is kept. This function should be applied for normal local adaptation (not for tone mapping operation)
+	* @param v0: compression effect for the local luminance adaptation processing, set a value between 0.6 and 0.9 for best results, a high value yields to a high compression effect
+	* @param meanLuminance: the a priori meann luminance of the input data (should be 128 for 8bits images but can vary greatly in case of High Dynamic Range Images (HDRI)
+	*/
+	void setV0CompressionParameter(const double v0, const double meanLuminance){ this->setV0CompressionParameter(v0, _maxInputValue, meanLuminance);};
+
+	/**
+	* local luminance adaptation setup, this function should be applied for normal local adaptation (not for tone mapping operation)
+	* @param v0: compression effect for the local luminance adaptation processing, set a value between 0.6 and 0.9 for best results, a high value yields to a high compression effect
+	*/
+	void setV0CompressionParameter(const double v0){ _v0=v0*_maxInputValue; _localLuminanceFactor=v0; _localLuminanceAddon=_maxInputValue*(1.0-v0);};
+
+	/**
+	* local luminance adaptation setup, this function should be applied for local adaptation applied to tone mapping operation
+	* @param v0: compression effect for the local luminance adaptation processing, set a value between 0.6 and 0.9 for best results, a high value yields to a high compression effect
+	* @param maxInputValue: the maximum amplitude value measured after local adaptation processing (c.f. function runFilter_LocalAdapdation & runFilter_LocalAdapdation_autonomous)
+	* @param meanLuminance: the a priori meann luminance of the input data (should be 128 for 8bits images but can vary greatly in case of High Dynamic Range Images (HDRI)
+	*/
+	void setV0CompressionParameterToneMapping(const double v0, const double maxInputValue, const double meanLuminance=128.0){ _v0=v0*maxInputValue; _localLuminanceFactor=1; _localLuminanceAddon=meanLuminance*_v0; _maxInputValue=maxInputValue;};
+
+	/**
+	* update compression parameters while keeping v0 parameter value
+	* @param meanLuminance the input frame mean luminance
+	*/
+	inline void updateCompressionParameter(const double meanLuminance){_localLuminanceFactor=1; _localLuminanceAddon=meanLuminance*_v0;};
+
+	/**
+	* @return the v0 compression parameter used to compute the local adaptation
+	*/
+	const double getV0CompressionParameter(){ return _v0/_maxInputValue;};
+
+	/**
+	* @return the output result of the object
+	*/
+	inline const std::valarray<double> &getOutput() const {return _filterOutput;};
+
+	/**
+	* @return number of rows of the filter
+	*/
+	inline const unsigned int getNBrows(){return _filterOutput.getNBrows();};
+
+	/**
+	* @return number of columns of the filter
+	*/
+	inline const unsigned int getNBcolumns(){return _filterOutput.getNBcolumns();};
+
+	/**
+	* @return number of pixels of the filter
+	*/
+	inline const unsigned int getNBpixels(){return _filterOutput.getNBpixels();};
+
+	/**
+	* force filter output to be normalized between 0 and maxValue
+	* @param maxValue: the maximum output value that is required
+	*/
+	inline void normalizeGrayOutput_0_maxOutputValue(const double maxValue){_filterOutput.normalizeGrayOutput_0_maxOutputValue(maxValue);};
+
+	/**
+	* force filter output to be normalized around 0 and rescaled with a sigmoide effect (extrem values saturation)
+	* @param maxValue: the maximum output value that is required
+	*/
+	inline void normalizeGrayOutputCentredSigmoide(){_filterOutput.normalizeGrayOutputCentredSigmoide();};
+
+	/**
+	* force filter output to be normalized : data centering and std normalisation
+	* @param maxValue: the maximum output value that is required
+	*/
+	inline void centerReductImageLuminance(){_filterOutput.centerReductImageLuminance();};
+
+	/**
+	* @return the maximum input buffer value
+	*/
+	inline const double getMaxInputValue(){return this->_maxInputValue;};
+
+	/**
+	* @return the maximum input buffer value
+	*/
+	inline void setMaxInputValue(const double newMaxInputValue){this->_maxInputValue=newMaxInputValue;};
+
+protected:
+
+	/////////////////////////
+	// data buffers
+	TemplateBuffer<double> _filterOutput; // primary buffer (contains processing outputs)
+	std::valarray<double> _localBuffer; // local secondary buffer
+	/////////////////////////
+	// PARAMETERS
+	unsigned int _halfNBrows;
+	unsigned int _halfNBcolumns;
+
+	// parameters buffers
+	std::valarray <double>_filteringCoeficientsTable;
+	std::valarray <double>_progressiveSpatialConstant;// pointer to a local table containing local spatial constant (allocated with the object)
+	std::valarray <double>_progressiveGain;// pointer to a local table containing local spatial constant (allocated with the object)
+
+	// local adaptation filtering parameters
+	double _v0; //value used for local luminance adaptation function
+	double _maxInputValue;
+	double _meanInputValue;
+	double _localLuminanceFactor;
+	double _localLuminanceAddon;
+
+	// protected data related to standard low pass filters parameters
+	double _a;
+	double _tau;
+	double _gain;
+
+	/////////////////////////
+	// FILTERS METHODS
+
+	// Basic low pass spation temporal low pass filter used by each retina filters
+	void _spatiotemporalLPfilter(const double *inputFrame, double *LPfilterOutput, const unsigned int coefTableOffset=0);
+	const double _squaringSpatiotemporalLPfilter(const double *inputFrame, double *outputFrame, const unsigned int filterIndex=0);
+
+	// LP filter with an irregular spatial filtering
+
+	// -> rewrites the input buffer
+	void _spatiotemporalLPfilter_Irregular(double *inputOutputFrame, const unsigned int filterIndex=0);
+	// writes the output on another buffer
+	void _spatiotemporalLPfilter_Irregular(const double *inputFrame, double *outputFrame, const unsigned int filterIndex=0);
+	// LP filter that squares the input and computes the output ONLY on the areas where the integrationAreas map are TRUE
+	void _localSquaringSpatioTemporalLPfilter(const double *inputFrame, double *LPfilterOutput, const unsigned int *integrationAreas, const unsigned int filterIndex=0);
+
+	// local luminance adaptation of the input in regard of localLuminance buffer
+	void _localLuminanceAdaptation(const double *inputFrame, const double *localLuminance, double *outputFrame);
+	// local luminance adaptation of the input in regard of localLuminance buffer, the input is rewrited and becomes the output
+	void _localLuminanceAdaptation(double *inputOutputFrame, const double *localLuminance);
+	// local adaptation applied on a range of values which can be positive and negative
+	void _localLuminanceAdaptationPosNegValues(const double *inputFrame, const double *localLuminance, double *outputFrame);
+
+
+	//////////////////////////////////////////////////////////////
+	// 1D directional filters used for the 2D low pass filtering
+
+	// 1D filters with image input
+	void _horizontalCausalFilter_addInput(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	// 1D filters  with image input that is squared in the function
+	void _squaringHorizontalCausalFilter(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	//  vertical anticausal filter that returns the mean value of its result
+	const double _verticalAnticausalFilter_returnMeanValue(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd);
+
+	// most simple functions: only perform 1D filtering with output=input (no add on)
+	void _horizontalCausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	void _horizontalAnticausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	void _verticalCausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd);
+	void _verticalAnticausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd);
+
+	// perform 1D filtering with output with varrying spatial coefficient
+	void _horizontalCausalFilter_Irregular(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	void _horizontalCausalFilter_Irregular_addInput(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	void _horizontalAnticausalFilter_Irregular(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd);
+	void _verticalCausalFilter_Irregular(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd);
+	void _verticalAnticausalFilter_Irregular_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd);
+
+
+	// 1D filters in which the output is multiplied by _gain
+	void _verticalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd); // this functions affects _gain at the output
+	void _horizontalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd); // this functions affects _gain at the output
+
+	// LP filter on specific parts of the picture instead of all the image
+	// same functions (some of them) but take a binary flag to allow integration, false flag means, 0 at the output...
+	void _local_squaringHorizontalCausalFilter(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas);
+	void _local_horizontalAnticausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd, const unsigned int *integrationAreas);
+	void _local_verticalCausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd, const unsigned int *integrationAreas);
+	void _local_verticalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd, const unsigned int *integrationAreas); // this functions affects _gain at the output
+
+};
+
+}
+#endif
+
+
diff --git a/modules/contrib/src/chamfermatching.cpp b/modules/contrib/src/chamfermatching.cpp
index d45f72f486..12ae018ee7 100644
--- a/modules/contrib/src/chamfermatching.cpp
+++ b/modules/contrib/src/chamfermatching.cpp
@@ -736,7 +736,7 @@ float ChamferMatcher::Matching::getAngle(coordinate_t a, coordinate_t b, int& dx
 void ChamferMatcher::Matching::findContourOrientations(const template_coords_t& coords, template_orientations_t& orientations)
 {
 	const int M = 5;
-	int coords_size = coords.size();
+	int coords_size = (int)coords.size();
 
     std::vector<float> angles(2*M);
         orientations.insert(orientations.begin(), coords_size, float(-3*CV_PI)); // mark as invalid in the beginning
@@ -808,11 +808,12 @@ ChamferMatcher::Template::Template(Mat& edge_image, float scale_) : addr_width(-
 
 	size.width = max.x - min.x;
 	size.height = max.y - min.y;
+	int coords_size = (int)coords.size();
 
-	center.x /= (coords.size()==0?1:coords.size());
-	center.y /= (coords.size()==0?1:coords.size());
+	center.x /= MAX(coords_size, 1);
+	center.y /= MAX(coords_size, 1);
 
-	for (size_t i=0;i<coords.size();++i) {
+	for (int i=0;i<coords_size;++i) {
 		coords[i].first -= center.x;
 		coords[i].second -= center.y;
 	}
diff --git a/modules/contrib/src/imagelogpolprojection.cpp b/modules/contrib/src/imagelogpolprojection.cpp
new file mode 100644
index 0000000000..206b95f0e6
--- /dev/null
+++ b/modules/contrib/src/imagelogpolprojection.cpp
@@ -0,0 +1,449 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+#include "imagelogpolprojection.hpp"
+
+#include <cmath>
+#include <iostream>
+
+// @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+
+namespace cv
+{
+
+// constructor
+ImageLogPolProjection::ImageLogPolProjection(const unsigned int nbRows, const unsigned int nbColumns, const PROJECTIONTYPE projection, const bool colorModeCapable)
+:BasicRetinaFilter(nbRows, nbColumns),
+ _sampledFrame(0),
+ _tempBuffer(_localBuffer),
+ _transformTable(0),
+ _irregularLPfilteredFrame(_filterOutput)
+{
+	_inputDoubleNBpixels=nbRows*nbColumns*2;
+	_selectedProjection = projection;
+	_reductionFactor=0;
+	_initOK=false;
+	_usefullpixelIndex=0;
+	_colorModeCapable=colorModeCapable;
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::allocating"<<std::endl;
+#endif
+	if (_colorModeCapable)
+	{
+		_tempBuffer.resize(nbRows*nbColumns*3);
+	}
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::done"<<std::endl;
+#endif
+
+	clearAllBuffers();
+}
+
+// destructor
+ImageLogPolProjection::~ImageLogPolProjection()
+{
+
+}
+
+
+// reset buffers method
+void ImageLogPolProjection::clearAllBuffers()
+{
+	_sampledFrame=0;
+	_tempBuffer=0;
+	BasicRetinaFilter::clearAllBuffers();
+}
+
+/**
+* resize retina color filter object (resize all allocated buffers)
+* @param NBrows: the new height size
+* @param NBcolumns: the new width size
+*/
+void ImageLogPolProjection::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+	BasicRetinaFilter::resize(NBrows, NBcolumns);
+	initProjection(_reductionFactor, _samplingStrenght);
+
+	// reset buffers method
+	clearAllBuffers();
+
+}
+
+// init functions depending on the projection type
+bool ImageLogPolProjection::initProjection(const double reductionFactor, const double samplingStrenght)
+{
+	switch(_selectedProjection)
+	{
+	case RETINALOGPROJECTION:
+		return _initLogRetinaSampling(reductionFactor, samplingStrenght);
+		break;
+	case CORTEXLOGPOLARPROJECTION:
+		return _initLogPolarCortexSampling(reductionFactor, samplingStrenght);
+		break;
+	default:
+		std::cout<<"ImageLogPolProjection::no projection setted up... performing default retina projection... take care"<<std::endl;
+		return _initLogRetinaSampling(reductionFactor, samplingStrenght);
+		break;
+	}
+}
+
+// -> private init functions dedicated to each projection
+bool ImageLogPolProjection::_initLogRetinaSampling(const double reductionFactor, const double samplingStrenght)
+{
+	_initOK=false;
+
+	if (_selectedProjection!=RETINALOGPROJECTION)
+	{
+		std::cerr<<"ImageLogPolProjection::initLogRetinaSampling: could not initialize logPolar projection for a log projection system\n -> you probably chose the wrong init function, use initLogPolarCortexSampling() instead"<<std::endl;
+		return false;
+	}
+	if (reductionFactor<1.0)
+	{
+		std::cerr<<"ImageLogPolProjection::initLogRetinaSampling: reduction factor must be superior to 0, skeeping initialisation..."<<std::endl;
+		return false;
+	}
+
+	// compute image output size
+	_outputNBrows=predictOutputSize(this->getNBrows(), reductionFactor);
+	_outputNBcolumns=predictOutputSize(this->getNBcolumns(), reductionFactor);
+	_outputNBpixels=_outputNBrows*_outputNBcolumns;
+	_outputDoubleNBpixels=_outputNBrows*_outputNBcolumns*2;
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::initLogRetinaSampling: Log resampled image resampling factor: "<<reductionFactor<<", strenght:"<<samplingStrenght<<std::endl;
+	std::cout<<"ImageLogPolProjection::initLogRetinaSampling: Log resampled image size: "<<_outputNBrows<<"*"<<_outputNBcolumns<<std::endl;
+#endif
+
+	// setup progressive prefilter that will be applied BEFORE log sampling
+	setProgressiveFilterConstants_CentredAccuracy(0.0, 0.0, 0.99);
+
+	// (re)create the image output buffer and transform table if the reduction factor changed
+	_sampledFrame.resize(_outputNBpixels*(1+(unsigned int)_colorModeCapable*2));
+
+	// specifiying new reduction factor after preliminar checks
+	_reductionFactor=reductionFactor;
+	_samplingStrenght=samplingStrenght;
+
+	// compute the rlim for symetric rows/columns sampling, then, the rlim is based on the smallest dimension
+	_minDimension=(double)(_filterOutput.getNBrows() < _filterOutput.getNBcolumns() ? _filterOutput.getNBrows() : _filterOutput.getNBcolumns());
+
+	// input frame dimensions dependent log sampling:
+	//double rlim=1.0/reductionFactor*(minDimension/2.0+samplingStrenght);
+
+	// input frame dimensions INdependent log sampling:
+	_azero=(1.0+reductionFactor*sqrt(samplingStrenght))/(reductionFactor*reductionFactor*samplingStrenght-1.0);
+	_alim=(1.0+_azero)/reductionFactor;
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::initLogRetinaSampling: rlim= "<<rlim<<std::endl;
+	std::cout<<"ImageLogPolProjection::initLogRetinaSampling: alim= "<<alim<<std::endl;
+#endif
+
+	// get half frame size
+	unsigned int halfOutputRows = _outputNBrows/2-1;
+	unsigned int halfOutputColumns = _outputNBcolumns/2-1;
+	unsigned int halfInputRows = _filterOutput.getNBrows()/2-1;
+	unsigned int halfInputColumns = _filterOutput.getNBcolumns()/2-1;
+
+	// computing log sampling matrix by computing quarters of images
+	// the original new image center (_filterOutput.getNBrows()/2, _filterOutput.getNBcolumns()/2) being at coordinate (_filterOutput.getNBrows()/(2*_reductionFactor), _filterOutput.getNBcolumns()/(2*_reductionFactor))
+
+	// -> use a temporary transform table which is bigger than the final one, we only report pixels coordinates that are included in the sampled picture
+	std::valarray<unsigned int> tempTransformTable(2*_outputNBpixels); // the structure would be: (pixelInputCoordinate n)(pixelOutputCoordinate n)(pixelInputCoordinate n+1)(pixelOutputCoordinate n+1)
+	_usefullpixelIndex=0;
+
+	double rMax=0;
+	halfInputRows<halfInputColumns ? rMax=(double)(halfInputRows*halfInputRows):rMax=(double)(halfInputColumns*halfInputColumns);
+
+	for (unsigned int idRow=0;idRow<halfOutputRows; ++idRow)
+	{
+		for (unsigned int idColumn=0;idColumn<halfOutputColumns; ++idColumn)
+		{
+			// get the pixel position in the original picture
+
+			// -> input frame dimensions dependent log sampling:
+			//double scale = samplingStrenght/(rlim-(double)sqrt(idRow*idRow+idColumn*idColumn));
+
+			// -> input frame dimensions INdependent log sampling:
+			double scale=getOriginalRadiusLength((double)sqrt((double)(idRow*idRow+idColumn*idColumn)));
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			std::cout<<"ImageLogPolProjection::initLogRetinaSampling: scale= "<<scale<<std::endl;
+			std::cout<<"ImageLogPolProjection::initLogRetinaSampling: scale2= "<<scale2<<std::endl;
+#endif
+			if (scale < 0) ///check it later
+				scale = 10000;
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			//            std::cout<<"ImageLogPolProjection::initLogRetinaSampling: scale= "<<scale<<std::endl;
+#endif
+
+			unsigned int u=(unsigned int)floor((double)idRow*scale);
+			unsigned int v=(unsigned int)floor((double)idColumn*scale);
+
+			// manage border effects
+			double length=u*u+v*v;
+			double radiusRatio=sqrt(rMax/length);
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			std::cout<<"ImageLogPolProjection::(inputH, inputW)="<<halfInputRows<<", "<<halfInputColumns<<", Rmax2="<<rMax<<std::endl;
+			std::cout<<"before ==> ImageLogPolProjection::(u, v)="<<u<<", "<<v<<", r="<<u*u+v*v<<std::endl;
+			std::cout<<"ratio ="<<radiusRatio<<std::endl;
+#endif
+
+			if (radiusRatio < 1.0)
+			{
+				u=(unsigned int)floor(radiusRatio*double(u));
+				v=(unsigned int)floor(radiusRatio*double(v));
+			}
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			std::cout<<"after ==> ImageLogPolProjection::(u, v)="<<u<<", "<<v<<", r="<<u*u+v*v<<std::endl;
+			std::cout<<"ImageLogPolProjection::("<<(halfOutputRows-idRow)<<", "<<idColumn+halfOutputColumns<<") <- ("<<halfInputRows-u<<", "<<v+halfInputColumns<<")"<<std::endl;
+			std::cout<<(halfOutputRows-idRow)+(halfOutputColumns+idColumn)*_outputNBrows<<" -> "<<(halfInputRows-u)+_filterOutput.getNBrows()*(halfInputColumns+v)<<std::endl;
+#endif
+
+			if ((u<halfInputRows)&&(v<halfInputColumns))
+			{
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+				std::cout<<"*** VALID ***"<<std::endl;
+#endif
+
+				// set pixel coordinate of the input picture in the transform table at the current log sampled pixel
+				// 1st quadrant
+				tempTransformTable[_usefullpixelIndex++]=(halfOutputColumns+idColumn)+(halfOutputRows-idRow)*_outputNBcolumns;
+				tempTransformTable[_usefullpixelIndex++]=_filterOutput.getNBcolumns()*(halfInputRows-u)+(halfInputColumns+v);
+				// 2nd quadrant
+				tempTransformTable[_usefullpixelIndex++]=(halfOutputColumns+idColumn)+(halfOutputRows+idRow)*_outputNBcolumns;
+				tempTransformTable[_usefullpixelIndex++]=_filterOutput.getNBcolumns()*(halfInputRows+u)+(halfInputColumns+v);
+				// 3rd quadrant
+				tempTransformTable[_usefullpixelIndex++]=(halfOutputColumns-idColumn)+(halfOutputRows-idRow)*_outputNBcolumns;
+				tempTransformTable[_usefullpixelIndex++]=_filterOutput.getNBcolumns()*(halfInputRows-u)+(halfInputColumns-v);
+				// 4td quadrant
+				tempTransformTable[_usefullpixelIndex++]=(halfOutputColumns-idColumn)+(halfOutputRows+idRow)*_outputNBcolumns;
+				tempTransformTable[_usefullpixelIndex++]=_filterOutput.getNBcolumns()*(halfInputRows+u)+(halfInputColumns-v);
+			}
+		}
+	}
+
+	// (re)creating and filling the transform table
+	_transformTable.resize(_usefullpixelIndex);
+	memcpy(&_transformTable[0], &tempTransformTable[0], sizeof(unsigned int)*_usefullpixelIndex);
+
+	// reset all buffers
+	clearAllBuffers();
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::initLogRetinaSampling: init done successfully"<<std::endl;
+#endif
+	_initOK=true;
+	return _initOK;
+}
+
+bool ImageLogPolProjection::_initLogPolarCortexSampling(const double reductionFactor, const double)
+{
+	_initOK=false;
+
+	if (_selectedProjection!=CORTEXLOGPOLARPROJECTION)
+	{
+		std::cerr<<"ImageLogPolProjection::could not initialize log projection for a logPolar projection system\n -> you probably chose the wrong init function, use initLogRetinaSampling() instead"<<std::endl;
+		return false;
+	}
+
+	if (reductionFactor<1.0)
+	{
+		std::cerr<<"ImageLogPolProjection::reduction factor must be superior to 0, skeeping initialisation..."<<std::endl;
+		return false;
+	}
+
+	// compute the smallest image size
+	unsigned int minDimension=(_filterOutput.getNBrows() < _filterOutput.getNBcolumns() ? _filterOutput.getNBrows() : _filterOutput.getNBcolumns());
+	// specifiying new reduction factor after preliminar checks
+	_reductionFactor=reductionFactor;
+	// compute image output size
+	_outputNBrows=(unsigned int)((double)minDimension/reductionFactor);
+	_outputNBcolumns=(unsigned int)((double)minDimension/reductionFactor);
+	_outputNBpixels=_outputNBrows*_outputNBcolumns;
+	_outputDoubleNBpixels=_outputNBrows*_outputNBcolumns*2;
+
+	// get half frame size
+	//unsigned int halfOutputRows = _outputNBrows/2-1;
+	//unsigned int halfOutputColumns = _outputNBcolumns/2-1;
+	unsigned int halfInputRows = _filterOutput.getNBrows()/2-1;
+	unsigned int halfInputColumns = _filterOutput.getNBcolumns()/2-1;
+
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+	std::cout<<"ImageLogPolProjection::Log resampled image size: "<<_outputNBrows<<"*"<<_outputNBcolumns<<std::endl;
+#endif
+
+	// setup progressive prefilter that will be applied BEFORE log sampling
+	setProgressiveFilterConstants_CentredAccuracy(0.0, 0.0, 0.99);
+
+	// (re)create the image output buffer and transform table if the reduction factor changed
+	_sampledFrame.resize(_outputNBpixels*(1+(unsigned int)_colorModeCapable*2));
+
+	// create the radius and orientation axis and fill them, radius E [0;1], orientation E[-pi, pi]
+	std::valarray<double> radiusAxis(_outputNBcolumns);
+	double radiusStep=2.30/(double)_outputNBcolumns;
+	for (unsigned int i=0;i<_outputNBcolumns;++i)
+	{
+		radiusAxis[i]=i*radiusStep;
+	}
+	std::valarray<double> orientationAxis(_outputNBrows);
+	double orientationStep=-2.0*CV_PI/(double)_outputNBrows;
+	for (unsigned int io=0;io<_outputNBrows;++io)
+	{
+		orientationAxis[io]=io*orientationStep;
+	}
+	// -> use a temporay transform table which is bigger than the final one, we only report pixels coordinates that are included in the sampled picture
+	std::valarray<unsigned int> tempTransformTable(2*_outputNBpixels); // the structure would be: (pixelInputCoordinate n)(pixelOutputCoordinate n)(pixelInputCoordinate n+1)(pixelOutputCoordinate n+1)
+	_usefullpixelIndex=0;
+
+	//std::cout<<"ImageLogPolProjection::Starting cortex projection"<<std::endl;
+	// compute transformation, get theta and Radius in reagrd of the output sampled pixel
+	double diagonalLenght=sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
+	for (unsigned int radiusIndex=0;radiusIndex<_outputNBcolumns;++radiusIndex)
+		for(unsigned int orientationIndex=0;orientationIndex<_outputNBrows;++orientationIndex)
+		{
+			double x=1.0+sinh(radiusAxis[radiusIndex])*cos(orientationAxis[orientationIndex]);
+			double y=sinh(radiusAxis[radiusIndex])*sin(orientationAxis[orientationIndex]);
+			// get the input picture coordinate
+			double R=diagonalLenght*sqrt(x*x+y*y)/(5.0+sqrt(x*x+y*y));
+			double theta=atan2(y,x);
+			// convert input polar coord into cartesian/C compatble coordinate
+			unsigned int columnIndex=(unsigned int)(cos(theta)*R)+halfInputColumns;
+			unsigned int rowIndex=(unsigned int)(sin(theta)*R)+halfInputRows;
+			//std::cout<<"ImageLogPolProjection::R="<<R<<" / Theta="<<theta<<" / (x, y)="<<columnIndex<<", "<<rowIndex<<std::endl;
+			if ((columnIndex<_filterOutput.getNBcolumns())&&(columnIndex>0)&&(rowIndex<_filterOutput.getNBrows())&&(rowIndex>0))
+			{
+				// set coordinate
+				tempTransformTable[_usefullpixelIndex++]=radiusIndex+orientationIndex*_outputNBcolumns;
+				tempTransformTable[_usefullpixelIndex++]= columnIndex+rowIndex*_filterOutput.getNBcolumns();
+			}
+		}
+
+	// (re)creating and filling the transform table
+	_transformTable.resize(_usefullpixelIndex);
+	memcpy(&_transformTable[0], &tempTransformTable[0], sizeof(unsigned int)*_usefullpixelIndex);
+
+	// reset all buffers
+	clearAllBuffers();
+	_initOK=true;
+	return true;
+}
+
+// action function
+std::valarray<double> &ImageLogPolProjection::runProjection(const std::valarray<double> &inputFrame, const double colorMode)
+{
+	if (_colorModeCapable&&colorMode)
+	{
+		// progressive filtering and storage of the result in _tempBuffer
+		_spatiotemporalLPfilter_Irregular(get_data(inputFrame), &_irregularLPfilteredFrame[0]);
+		_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_tempBuffer[0]); // warning, temporal issue may occur, if the temporal constant is not NULL !!!
+
+		_spatiotemporalLPfilter_Irregular(get_data(inputFrame)+_filterOutput.getNBpixels(), &_irregularLPfilteredFrame[0]);
+		_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_tempBuffer[0]+_filterOutput.getNBpixels());
+
+		_spatiotemporalLPfilter_Irregular(get_data(inputFrame)+_filterOutput.getNBpixels()*2, &_irregularLPfilteredFrame[0]);
+		_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_tempBuffer[0]+_filterOutput.getNBpixels()*2);
+
+		// applying image projection/resampling
+		register unsigned int *transformTablePTR=&_transformTable[0];
+		for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2)
+		{
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			std::cout<<"ImageLogPolProjection::i:"<<i<<"output(max="<<_outputNBpixels<<")="<<_transformTable[i]<<" / intput(max="<<_filterOutput.getNBpixels()<<")="<<_transformTable[i+1]<<std::endl;
+#endif
+			_sampledFrame[*(transformTablePTR)]=_tempBuffer[*(transformTablePTR+1)];
+			_sampledFrame[*(transformTablePTR)+_outputNBpixels]=_tempBuffer[*(transformTablePTR+1)+_filterOutput.getNBpixels()];
+			_sampledFrame[*(transformTablePTR)+_outputDoubleNBpixels]=_tempBuffer[*(transformTablePTR+1)+_inputDoubleNBpixels];
+		}
+
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+		std::cout<<"ImageLogPolProjection::runProjection: color image projection OK"<<std::endl;
+#endif
+		//normalizeGrayOutput_0_maxOutputValue(_sampledFrame, _outputNBpixels);
+	}else
+	{
+		_spatiotemporalLPfilter_Irregular(get_data(inputFrame), &_irregularLPfilteredFrame[0]);
+		_spatiotemporalLPfilter_Irregular(&_irregularLPfilteredFrame[0], &_irregularLPfilteredFrame[0]);
+		// applying image projection/resampling
+		register unsigned int *transformTablePTR=&_transformTable[0];
+		for (unsigned int i=0 ; i<_usefullpixelIndex ; i+=2, transformTablePTR+=2)
+		{
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+			std::cout<<"i:"<<i<<"output(max="<<_outputNBpixels<<")="<<_transformTable[i]<<" / intput(max="<<_filterOutput.getNBpixels()<<")="<<_transformTable[i+1]<<std::endl;
+#endif
+			_sampledFrame[*(transformTablePTR)]=_irregularLPfilteredFrame[*(transformTablePTR+1)];
+		}
+		//normalizeGrayOutput_0_maxOutputValue(_sampledFrame, _outputNBpixels);
+#ifdef IMAGELOGPOLPROJECTION_DEBUG
+		std::cout<<"ImageLogPolProjection::runProjection: gray level image projection OK"<<std::endl;
+#endif
+	}
+
+	return _sampledFrame;
+}
+
+}
diff --git a/modules/contrib/src/imagelogpolprojection.hpp b/modules/contrib/src/imagelogpolprojection.hpp
new file mode 100644
index 0000000000..78b93f6ba6
--- /dev/null
+++ b/modules/contrib/src/imagelogpolprojection.hpp
@@ -0,0 +1,236 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * The name of the copyright holders may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+** 
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+*******************************************************************************/
+
+#ifndef IMAGELOGPOLPROJECTION_H_
+#define IMAGELOGPOLPROJECTION_H_
+
+/**
+* @class ImageLogPolProjection
+* @brief class able to perform a log sampling of an image input (models the log sampling of the photoreceptors of the retina)
+* or a log polar projection which models the retina information projection on the primary visual cortex: a linear projection in the center for detail analysis and a log projection of the borders (low spatial frequency motion information in general)
+*
+* collaboration: Barthelemy DURETTE who experimented the retina log projection
+-> "Traitement visuels Bio mimtiques pour la supplance perceptive", internal technical report, May 2005, Gipsa-lab/DIS, Grenoble, FRANCE
+*
+* * TYPICAL USE:
+*
+* // create object, here for a log sampling (keyword:RETINALOGPROJECTION): (dynamic object allocation sample)
+* ImageLogPolProjection *imageSamplingTool;
+* imageSamplingTool = new ImageLogPolProjection(frameSizeRows, frameSizeColumns, RETINALOGPROJECTION);
+*
+* // init log projection:
+* imageSamplingTool->initProjection(1.0, 15.0);
+*
+* // during program execution, call the log transform applied to a frame called "FrameBuffer" :
+* imageSamplingTool->runProjection(FrameBuffer);
+* // get output frame and its size:
+* const unsigned int logSampledFrame_nbRows=imageSamplingTool->getOutputNBrows();
+* const unsigned int logSampledFrame_nbColumns=imageSamplingTool->getOutputNBcolumns();
+* const double *logSampledFrame=imageSamplingTool->getSampledFrame();
+*
+* // at the end of the program, destroy object:
+* delete imageSamplingTool;
+*
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+*/
+
+//#define __IMAGELOGPOLPROJECTION_DEBUG // used for std output debug information
+
+#include "basicretinafilter.hpp"
+
+
+namespace cv
+{
+
+class ImageLogPolProjection:public BasicRetinaFilter
+{
+public:
+
+	enum PROJECTIONTYPE{RETINALOGPROJECTION, CORTEXLOGPOLARPROJECTION};
+
+	/**
+	* constructor, just specifies the image input size and the projection type, no projection initialisation is done
+	* -> use initLogRetinaSampling() or initLogPolarCortexSampling() for that
+	* @param nbRows: number of rows of the input image
+	* @param nbColumns: number of columns of the input image
+	* @param projection: the type of projection, RETINALOGPROJECTION or CORTEXLOGPOLARPROJECTION
+	* @param colorMode: specifies if the projection is applied on a grayscale image (false) or color images (3 layers) (true)
+	*/
+	ImageLogPolProjection(const unsigned int nbRows, const unsigned int nbColumns, const PROJECTIONTYPE projection, const bool colorMode=false);
+
+	/**
+	* standard destructor
+	*/
+	virtual ~ImageLogPolProjection();
+
+	/**
+	* function that clears all buffers of the object
+	*/
+	void clearAllBuffers();
+
+	/**
+	* resize retina color filter object (resize all allocated buffers)
+	* @param NBrows: the new height size
+	* @param NBcolumns: the new width size
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+	/**
+	* init function depending on the projection type
+	* @param reductionFactor: the size reduction factor of the ouptup image in regard of the size of the input image, must be superior to 1
+	* @param samplingStrenght: specifies the strenght of the log compression effect (magnifying coefficient)
+	* @return true if the init was performed without any errors
+	*/
+	bool initProjection(const double reductionFactor, const double samplingStrenght);
+
+	/**
+	* main funtion of the class: run projection function
+	* @param inputFrame: the input frame to be processed
+	* @return the output frame
+	*/
+	std::valarray<double> &runProjection(const std::valarray<double> &inputFrame, const double colorMode=false);
+
+	/**
+	* @return the numbers of rows (height) of the images OUTPUTS of the object
+	*/
+	inline const unsigned int getOutputNBrows(){return _outputNBrows;};
+
+	/**
+	* @return the numbers of columns (width) of the images OUTPUTS of the object
+	*/
+	inline const unsigned int getOutputNBcolumns(){return _outputNBcolumns;};
+
+	/**
+	* main funtion of the class: run projection function
+	* @param size: one of the input frame initial dimensions to be processed
+	* @return the output frame dimension
+	*/
+	inline static const unsigned int predictOutputSize(const unsigned int size, const double reductionFactor){return (unsigned int)((double)size/reductionFactor);};
+
+	/**
+	* @return the output of the filter which applies an irregular Low Pass spatial filter to the imag input (see function
+	*/
+	inline const std::valarray<double> &getIrregularLPfilteredInputFrame() const {return _irregularLPfilteredFrame;};
+
+	/**
+	* function which allows to retrieve the output frame which was updated after the "runProjection(...) function BasicRetinaFilter::runProgressiveFilter(...)
+	* @return the projection result
+	*/
+	inline const std::valarray<double> &getSampledFrame() const {return _sampledFrame;};
+
+	/**
+	* function which allows gives the tranformation table, its size is (getNBrows()*getNBcolumns()*2)
+	* @return the transformation matrix [outputPixIndex_i, inputPixIndex_i, outputPixIndex_i+1, inputPixIndex_i+1....]
+	*/
+	inline const std::valarray<unsigned int> &getSamplingMap() const {return _transformTable;};
+
+	inline const double getOriginalRadiusLength(const double projectedRadiusLength){return _azero/(_alim-projectedRadiusLength*2.0/_minDimension);};
+
+	//    unsigned int getInputPixelIndex(const unsigned int ){ return  _transformTable[index*2+1]};
+
+private:
+	PROJECTIONTYPE _selectedProjection;
+
+	// size of the image output
+	unsigned int _outputNBrows;
+	unsigned int _outputNBcolumns;
+	unsigned int _outputNBpixels;
+	unsigned int _outputDoubleNBpixels;
+	unsigned int _inputDoubleNBpixels;
+
+	// is the object able to manage color flag
+	bool _colorModeCapable;
+	// sampling strenght factor
+	double _samplingStrenght;
+	// sampling reduction factor
+	double _reductionFactor;
+
+	// log sampling parameters
+	double _azero;
+	double _alim;
+	double _minDimension;
+
+	// template buffers
+	std::valarray<double>_sampledFrame;
+	std::valarray<double>&_tempBuffer;
+	std::valarray<unsigned int>_transformTable;
+
+	std::valarray<double> &_irregularLPfilteredFrame; // just a reference for easier understanding
+	unsigned int _usefullpixelIndex;
+
+	// init transformation tables
+	bool _computeLogProjection();
+	bool _computeLogPolarProjection();
+
+	// specifies if init was done correctly
+	bool _initOK;
+	// private init projections functions called by "initProjection(...)" function
+	bool _initLogRetinaSampling(const double reductionFactor, const double samplingStrenght);
+	bool _initLogPolarCortexSampling(const double reductionFactor, const double samplingStrenght);
+
+};
+
+}
+#endif /*IMAGELOGPOLPROJECTION_H_*/
diff --git a/modules/contrib/src/magnoretinafilter.cpp b/modules/contrib/src/magnoretinafilter.cpp
new file mode 100644
index 0000000000..8956539f26
--- /dev/null
+++ b/modules/contrib/src/magnoretinafilter.cpp
@@ -0,0 +1,207 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+
+#include <iostream>
+
+#include "magnoretinafilter.hpp"
+
+#include <cmath>
+
+namespace cv
+{
+// Constructor and Desctructor of the OPL retina filter
+MagnoRetinaFilter::MagnoRetinaFilter(const unsigned int NBrows, const unsigned int NBcolumns)
+:BasicRetinaFilter(NBrows, NBcolumns, 2),
+ _previousInput_ON(NBrows*NBcolumns),
+ _previousInput_OFF(NBrows*NBcolumns),
+ _amacrinCellsTempOutput_ON(NBrows*NBcolumns),
+ _amacrinCellsTempOutput_OFF(NBrows*NBcolumns),
+ _magnoXOutputON(NBrows*NBcolumns),
+ _magnoXOutputOFF(NBrows*NBcolumns),
+ _localProcessBufferON(NBrows*NBcolumns),
+ _localProcessBufferOFF(NBrows*NBcolumns)
+{
+	_magnoYOutput=&_filterOutput;
+	_magnoYsaturated=&_localBuffer;
+
+
+	clearAllBuffers();
+
+#ifdef IPL_RETINA_ELEMENT_DEBUG
+	std::cout<<"MagnoRetinaFilter::Init IPL retina filter at specified frame size OK"<<std::endl;
+#endif
+}
+
+MagnoRetinaFilter::~MagnoRetinaFilter()
+{
+#ifdef IPL_RETINA_ELEMENT_DEBUG
+	std::cout<<"MagnoRetinaFilter::Delete IPL retina filter OK"<<std::endl;
+#endif
+}
+
+// function that clears all buffers of the object
+void MagnoRetinaFilter::clearAllBuffers()
+{
+	BasicRetinaFilter::clearAllBuffers();
+	_previousInput_ON=0;
+	_previousInput_OFF=0;
+	_amacrinCellsTempOutput_ON=0;
+	_amacrinCellsTempOutput_OFF=0;
+	_magnoXOutputON=0;
+	_magnoXOutputOFF=0;
+	_localProcessBufferON=0;
+	_localProcessBufferOFF=0;
+
+}
+
+/**
+* resize retina magno filter object (resize all allocated buffers
+* @param NBrows: the new height size
+* @param NBcolumns: the new width size
+*/
+void MagnoRetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+	BasicRetinaFilter::resize(NBrows, NBcolumns);
+	_previousInput_ON.resize(NBrows*NBcolumns);
+	_previousInput_OFF.resize(NBrows*NBcolumns);
+	_amacrinCellsTempOutput_ON.resize(NBrows*NBcolumns);
+	_amacrinCellsTempOutput_OFF.resize(NBrows*NBcolumns);
+	_magnoXOutputON.resize(NBrows*NBcolumns);
+	_magnoXOutputOFF.resize(NBrows*NBcolumns);
+	_localProcessBufferON.resize(NBrows*NBcolumns);
+	_localProcessBufferOFF.resize(NBrows*NBcolumns);
+
+	// to be sure, relink buffers
+	_magnoYOutput=&_filterOutput;
+	_magnoYsaturated=&_localBuffer;
+
+	// reset all buffers
+	clearAllBuffers();
+}
+
+void MagnoRetinaFilter::setCoefficientsTable(const double parasolCells_beta, const double parasolCells_tau, const double parasolCells_k, const double amacrinCellsTemporalCutFrequency, const double localAdaptIntegration_tau, const double localAdaptIntegration_k )
+{
+	_temporalCoefficient=exp(-1.0/amacrinCellsTemporalCutFrequency);
+	// the first set of parameters is dedicated to the low pass filtering property of the ganglion cells
+	BasicRetinaFilter::setLPfilterParameters(parasolCells_beta, parasolCells_tau, parasolCells_k, 0);
+	// the second set of parameters is dedicated to the ganglion cells output intergartion for their local adaptation property
+	BasicRetinaFilter::setLPfilterParameters(0, localAdaptIntegration_tau, localAdaptIntegration_k, 1);
+}
+
+void MagnoRetinaFilter::_amacrineCellsComputing(const double *OPL_ON, const double *OPL_OFF)
+{
+	register const double *OPL_ON_PTR=OPL_ON;
+	register const double *OPL_OFF_PTR=OPL_OFF;
+	register double *previousInput_ON_PTR= &_previousInput_ON[0];
+	register double *previousInput_OFF_PTR= &_previousInput_OFF[0];
+	register double *amacrinCellsTempOutput_ON_PTR= &_amacrinCellsTempOutput_ON[0];
+	register double *amacrinCellsTempOutput_OFF_PTR= &_amacrinCellsTempOutput_OFF[0];
+
+	for (unsigned int IDpixel=0 ; IDpixel<this->getNBpixels(); ++IDpixel)
+	{
+
+		/* Compute ON and OFF amacrin cells high pass temporal filter */
+		double magnoXonPixelResult = _temporalCoefficient*(*amacrinCellsTempOutput_ON_PTR+ *OPL_ON_PTR-*previousInput_ON_PTR);
+		*(amacrinCellsTempOutput_ON_PTR++)=((double)(magnoXonPixelResult>0))*magnoXonPixelResult;
+
+		double magnoXoffPixelResult = _temporalCoefficient*(*amacrinCellsTempOutput_OFF_PTR+ *OPL_OFF_PTR-*previousInput_OFF_PTR);
+		*(amacrinCellsTempOutput_OFF_PTR++)=((double)(magnoXoffPixelResult>0))*magnoXoffPixelResult;
+
+		/* prepare next loop */
+		*(previousInput_ON_PTR++)=*(OPL_ON_PTR++);
+		*(previousInput_OFF_PTR++)=*(OPL_OFF_PTR++);
+
+	}
+}
+
+// launch filter that runs all the IPL filter
+const std::valarray<double> &MagnoRetinaFilter::runFilter(const std::valarray<double> &OPL_ON, const std::valarray<double> &OPL_OFF)
+{
+	// Compute the high pass temporal filter
+	_amacrineCellsComputing(get_data(OPL_ON), get_data(OPL_OFF));
+
+	// apply low pass filtering on ON and OFF ways after temporal high pass filtering
+	_spatiotemporalLPfilter(&_amacrinCellsTempOutput_ON[0], &_magnoXOutputON[0], 0);
+	_spatiotemporalLPfilter(&_amacrinCellsTempOutput_OFF[0], &_magnoXOutputOFF[0], 0);
+
+	// local adaptation of the ganglion cells to the local contrast of the moving contours
+	_spatiotemporalLPfilter(&_magnoXOutputON[0], &_localProcessBufferON[0], 1);
+	_localLuminanceAdaptation(&_magnoXOutputON[0], &_localProcessBufferON[0]);
+	_spatiotemporalLPfilter(&_magnoXOutputOFF[0], &_localProcessBufferOFF[0], 1);
+	_localLuminanceAdaptation(&_magnoXOutputOFF[0], &_localProcessBufferOFF[0]);
+
+	/* Compute MagnoY */
+	register double *magnoYOutput= &(*_magnoYOutput)[0];
+	register double *magnoXOutputON_PTR= &_magnoXOutputON[0];
+	register double *magnoXOutputOFF_PTR= &_magnoXOutputOFF[0];
+	for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
+		*(magnoYOutput++)=*(magnoXOutputON_PTR++)+*(magnoXOutputOFF_PTR++);
+
+	return (*_magnoYOutput);
+}
+}
+
+
diff --git a/modules/contrib/src/magnoretinafilter.hpp b/modules/contrib/src/magnoretinafilter.hpp
new file mode 100644
index 0000000000..8a6d329cbe
--- /dev/null
+++ b/modules/contrib/src/magnoretinafilter.hpp
@@ -0,0 +1,203 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * The name of the copyright holders may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+** 
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+*******************************************************************************/
+
+#ifndef MagnoRetinaFilter_H_
+#define MagnoRetinaFilter_H_
+
+/**
+* @class MagnoRetinaFilter
+* @brief class which describes the magnocellular channel of the retina:
+* -> performs a moving contours extraction with powerfull local data enhancement
+*
+* TYPICAL USE:
+*
+* // create object at a specified picture size
+* MagnoRetinaFilter *movingContoursExtractor;
+* movingContoursExtractor =new MagnoRetinaFilter(frameSizeRows, frameSizeColumns);
+*
+* // init gain, spatial and temporal parameters:
+* movingContoursExtractor->setCoefficientsTable(0, 0.7, 5, 3);
+*
+* // during program execution, call the filter for contours extraction for an input picture called "FrameBuffer":
+* movingContoursExtractor->runfilter(FrameBuffer);
+*
+* // get the output frame, check in the class description below for more outputs:
+* const double *movingContours=movingContoursExtractor->getMagnoYsaturated();
+*
+* // at the end of the program, destroy object:
+* delete movingContoursExtractor;
+
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+* Based on Alexandre BENOIT thesis: "Le système visuel humain au secours de la vision par ordinateur"
+*/
+
+#include "basicretinafilter.hpp"
+
+//#define _IPL_RETINA_ELEMENT_DEBUG
+
+namespace cv
+{
+
+class MagnoRetinaFilter: public BasicRetinaFilter
+{
+public:
+	/**
+	* constructor parameters are only linked to image input size
+	* @param NBrows: number of rows of the input image
+	* @param NBcolumns: number of columns of the input image
+	*/
+	MagnoRetinaFilter(const unsigned int NBrows, const unsigned int NBcolumns);
+
+
+	/**
+	* destructor
+	*/
+	virtual ~MagnoRetinaFilter();
+
+	/**
+	* function that clears all buffers of the object
+	*/
+	void clearAllBuffers();
+
+	/**
+	* resize retina magno filter object (resize all allocated buffers)
+	* @param NBrows: the new height size
+	* @param NBcolumns: the new width size
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+	/**
+	* set parameters values
+	* @param parasolCells_beta: the low pass filter gain used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), typical value is 0
+	* @param parasolCells_tau: the low pass filter time constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical value is 0 (immediate response)
+	* @param parasolCells_k: the low pass filter spatial constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical value is 5
+	* @param amacrinCellsTemporalCutFrequency: the time constant of the first order high pass fiter of the magnocellular way (motion information channel), unit is frames, tipicall value is 5
+	* @param localAdaptIntegration_tau: specifies the temporal constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+	* @param localAdaptIntegration_k: specifies the spatial constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+	*/
+	void setCoefficientsTable(const double parasolCells_beta, const double parasolCells_tau, const double parasolCells_k, const double amacrinCellsTemporalCutFrequency, const double localAdaptIntegration_tau, const double localAdaptIntegration_k);
+
+	/**
+	* launch filter that runs all the IPL magno filter (model of the magnocellular channel of the Inner Plexiform Layer of the retina)
+	* @param OPL_ON: the output of the bipolar ON cells of the retina (available from the ParvoRetinaFilter class (getBipolarCellsON() function)
+	* @param OPL_OFF: the output of the bipolar OFF cells of the retina (available from the ParvoRetinaFilter class (getBipolarCellsOFF() function)
+	* @return the processed result without post-processing
+	*/
+	const std::valarray<double> &runFilter(const std::valarray<double> &OPL_ON, const std::valarray<double> &OPL_OFF);
+
+	/**
+	* @return the Magnocellular ON channel filtering output
+	*/
+	inline const std::valarray<double> &getMagnoON() const {return _magnoXOutputON;};
+
+	/**
+	* @return the Magnocellular OFF channel filtering output
+	*/
+	inline const std::valarray<double> &getMagnoOFF() const {return _magnoXOutputOFF;};
+
+	/**
+	* @return the Magnocellular Y (sum of the ON and OFF magno channels) filtering output
+	*/
+	inline const std::valarray<double> &getMagnoYsaturated() const {return *_magnoYsaturated;};
+
+	/**
+	* applies an image normalization which saturates the high output values by the use of an assymetric sigmoide
+	*/
+	inline void normalizeGrayOutputNearZeroCentreredSigmoide(){_filterOutput.normalizeGrayOutputNearZeroCentreredSigmoide(&(*_magnoYOutput)[0], &(*_magnoYsaturated)[0]);};
+
+	/**
+	* @return the horizontal cells' temporal constant
+	*/
+	inline const double getTemporalConstant(){return this->_filteringCoeficientsTable[2];};
+
+private:
+
+	// related pointers to these buffers
+	std::valarray<double> _previousInput_ON;
+	std::valarray<double> _previousInput_OFF;
+	std::valarray<double> _amacrinCellsTempOutput_ON;
+	std::valarray<double> _amacrinCellsTempOutput_OFF;
+	std::valarray<double> _magnoXOutputON;
+	std::valarray<double> _magnoXOutputOFF;
+	std::valarray<double> _localProcessBufferON;
+	std::valarray<double> _localProcessBufferOFF;
+	// reference to parent buffers and allow better readability
+	TemplateBuffer<double> *_magnoYOutput;
+	std::valarray<double> *_magnoYsaturated;
+
+	// varialbles
+	double _temporalCoefficient;
+
+	// amacrine cells filter : high pass temporal filter
+	void _amacrineCellsComputing(const double *ONinput, const double *OFFinput);
+
+
+};
+
+}
+
+#endif /*MagnoRetinaFilter_H_*/
+
+
diff --git a/modules/contrib/src/parvoretinafilter.cpp b/modules/contrib/src/parvoretinafilter.cpp
new file mode 100644
index 0000000000..4b730d024d
--- /dev/null
+++ b/modules/contrib/src/parvoretinafilter.cpp
@@ -0,0 +1,227 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+
+#include "parvoretinafilter.hpp"
+
+// @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+
+#include <iostream>
+#include <cmath>
+
+namespace cv
+{
+//////////////////////////////////////////////////////////
+//                 OPL RETINA FILTER
+//////////////////////////////////////////////////////////
+
+// Constructor and Desctructor of the OPL retina filter
+
+ParvoRetinaFilter::ParvoRetinaFilter(const unsigned int NBrows, const unsigned int NBcolumns)
+:BasicRetinaFilter(NBrows, NBcolumns, 3),
+ _photoreceptorsOutput(NBrows*NBcolumns),
+ _horizontalCellsOutput(NBrows*NBcolumns),
+ _parvocellularOutputON(NBrows*NBcolumns),
+ _parvocellularOutputOFF(NBrows*NBcolumns),
+ _bipolarCellsOutputON(NBrows*NBcolumns),
+ _bipolarCellsOutputOFF(NBrows*NBcolumns),
+ _localAdaptationOFF(NBrows*NBcolumns)
+{
+	// link to the required local parent adaptation buffers
+	_localAdaptationON=&_localBuffer;
+	_parvocellularOutputONminusOFF=&_filterOutput;
+	// (*_localAdaptationON)=&_localBuffer;
+	// (*_parvocellularOutputONminusOFF)=&(BasicRetinaFilter::TemplateBuffer);
+
+	// init: set all the values to 0
+	clearAllBuffers();
+
+
+#ifdef OPL_RETINA_ELEMENT_DEBUG
+	std::cout<<"ParvoRetinaFilter::Init OPL retina filter at specified frame size OK\n"<<std::endl;
+#endif
+
+}
+
+ParvoRetinaFilter::~ParvoRetinaFilter()
+{
+
+#ifdef OPL_RETINA_ELEMENT_DEBUG
+	std::cout<<"ParvoRetinaFilter::Delete OPL retina filter OK"<<std::endl;
+#endif
+}
+
+////////////////////////////////////
+// functions of the PARVO filter
+////////////////////////////////////
+
+// function that clears all buffers of the object
+void ParvoRetinaFilter::clearAllBuffers()
+{
+	BasicRetinaFilter::clearAllBuffers();
+	_photoreceptorsOutput=0;
+	_horizontalCellsOutput=0;
+	_parvocellularOutputON=0;
+	_parvocellularOutputOFF=0;
+	_bipolarCellsOutputON=0;
+	_bipolarCellsOutputOFF=0;
+	_localAdaptationOFF=0;
+}
+
+/**
+* resize parvo retina filter object (resize all allocated buffers
+* @param NBrows: the new height size
+* @param NBcolumns: the new width size
+*/
+void ParvoRetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+	BasicRetinaFilter::resize(NBrows, NBcolumns);
+	_photoreceptorsOutput.resize(NBrows*NBcolumns);
+	_horizontalCellsOutput.resize(NBrows*NBcolumns);
+	_parvocellularOutputON.resize(NBrows*NBcolumns);
+	_parvocellularOutputOFF.resize(NBrows*NBcolumns);
+	_bipolarCellsOutputON.resize(NBrows*NBcolumns);
+	_bipolarCellsOutputOFF.resize(NBrows*NBcolumns);
+	_localAdaptationOFF.resize(NBrows*NBcolumns);
+
+	// link to the required local parent adaptation buffers
+	_localAdaptationON=&_localBuffer;
+	_parvocellularOutputONminusOFF=&_filterOutput;
+
+	// clean buffers
+	clearAllBuffers();
+}
+
+// change the parameters of the filter
+void ParvoRetinaFilter::setOPLandParvoFiltersParameters(const double beta1, const double tau1, const double k1, const double beta2, const double tau2, const double k2)
+{
+	// init photoreceptors low pass filter
+	setLPfilterParameters(beta1, tau1, k1);
+	// init horizontal cells low pass filter
+	setLPfilterParameters(beta2, tau2, k2, 1);
+	// init parasol ganglion cells low pass filter (default parameters)
+	setLPfilterParameters(0, tau1, k1, 2);
+
+}
+
+// update/set size of the frames
+
+// run filter for a new frame input
+// output return is (*_parvocellularOutputONminusOFF)
+const std::valarray<double> &ParvoRetinaFilter::runFilter(const std::valarray<double> &inputFrame, const bool useParvoOutput)
+{
+	_spatiotemporalLPfilter(get_data(inputFrame), &_photoreceptorsOutput[0]);
+	_spatiotemporalLPfilter(&_photoreceptorsOutput[0], &_horizontalCellsOutput[0], 1);
+	_OPL_OnOffWaysComputing();
+
+	if (useParvoOutput)
+	{
+		// local adaptation processes on ON and OFF ways
+		_spatiotemporalLPfilter(&_bipolarCellsOutputON[0], &(*_localAdaptationON)[0], 2);
+		_localLuminanceAdaptation(&_parvocellularOutputON[0], &(*_localAdaptationON)[0]);
+
+		_spatiotemporalLPfilter(&_bipolarCellsOutputOFF[0], &_localAdaptationOFF[0], 2);
+		_localLuminanceAdaptation(&_parvocellularOutputOFF[0], &_localAdaptationOFF[0]);
+
+		//// Final loop that computes the main output of this filter
+		//
+		//// loop that makes the difference between photoreceptor cells output and horizontal cells
+		//// positive part goes on the ON way, negative pat goes on the OFF way
+		register double *parvocellularOutputONminusOFF_PTR=&(*_parvocellularOutputONminusOFF)[0];
+		register double *parvocellularOutputON_PTR=&_parvocellularOutputON[0];
+		register double *parvocellularOutputOFF_PTR=&_parvocellularOutputOFF[0];
+
+		for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
+			*(parvocellularOutputONminusOFF_PTR++)= (*(parvocellularOutputON_PTR++)-*(parvocellularOutputOFF_PTR++));
+	}
+	return (*_parvocellularOutputONminusOFF);
+}
+
+void ParvoRetinaFilter::_OPL_OnOffWaysComputing()
+{
+	// loop that makes the difference between photoreceptor cells output and horizontal cells
+	// positive part goes on the ON way, negative pat goes on the OFF way
+	register double *photoreceptorsOutput_PTR= &_photoreceptorsOutput[0];
+	register double *horizontalCellsOutput_PTR= &_horizontalCellsOutput[0];
+	register double *bipolarCellsON_PTR = &_bipolarCellsOutputON[0];
+	register double *bipolarCellsOFF_PTR = &_bipolarCellsOutputOFF[0];
+	register double *parvocellularOutputON_PTR= &_parvocellularOutputON[0];
+	register double *parvocellularOutputOFF_PTR= &_parvocellularOutputOFF[0];
+
+	// compute bipolar cells response equal to photoreceptors minus horizontal cells response
+	// and copy the result on parvo cellular outputs... keeping time before their local contrast adaptation for final result
+	for (register unsigned int IDpixel=0 ; IDpixel<_filterOutput.getNBpixels() ; ++IDpixel)
+	{
+		double pixelDifference = *(photoreceptorsOutput_PTR++) -*(horizontalCellsOutput_PTR++);
+		// test condition to allow write pixelDifference in ON or OFF buffer and 0 in the over
+		double isPositive=(double) (pixelDifference>0);
+
+		// ON and OFF channels writing step
+		*(parvocellularOutputON_PTR++)=*(bipolarCellsON_PTR++) = isPositive*pixelDifference;
+		*(parvocellularOutputOFF_PTR++)=*(bipolarCellsOFF_PTR++)= (isPositive-1.0)*pixelDifference;
+	}
+}
+}
+
diff --git a/modules/contrib/src/parvoretinafilter.hpp b/modules/contrib/src/parvoretinafilter.hpp
new file mode 100644
index 0000000000..9ce75a2906
--- /dev/null
+++ b/modules/contrib/src/parvoretinafilter.hpp
@@ -0,0 +1,222 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * The name of the copyright holders may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+** 
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+*******************************************************************************/
+
+#ifndef ParvoRetinaFilter_H_
+#define ParvoRetinaFilter_H_
+
+/**
+* @class ParvoRetinaFilter
+* @brief class which describes the OPL retina model and the Inner Plexiform Layer parvocellular channel of the retina:
+* -> performs a contours extraction with powerfull local data enhancement as at the retina level
+* -> spectrum whitening occurs at the OPL (Outer Plexiform Layer) of the retina: corrects the 1/f spectrum tendancy of natural images
+* ---> enhances details with mid spatial frequencies, attenuates low spatial frequencies (luminance), attenuates high temporal frequencies and high spatial frequencies, etc.
+*
+* TYPICAL USE:
+*
+* // create object at a specified picture size
+* ParvoRetinaFilter *contoursExtractor;
+* contoursExtractor =new ParvoRetinaFilter(frameSizeRows, frameSizeColumns);
+*
+* // init gain, spatial and temporal parameters:
+* contoursExtractor->setCoefficientsTable(0, 0.7, 1, 0, 7, 1);
+*
+* // during program execution, call the filter for contours extraction for an input picture called "FrameBuffer":
+* contoursExtractor->runfilter(FrameBuffer);
+*
+* // get the output frame, check in the class description below for more outputs:
+* const double *contours=contoursExtractor->getParvoONminusOFF();
+*
+* // at the end of the program, destroy object:
+* delete contoursExtractor;
+
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+* Based on Alexandre BENOIT thesis: "Le système visuel humain au secours de la vision par ordinateur"
+*
+*/
+
+#include "basicretinafilter.hpp"
+
+
+//#define _OPL_RETINA_ELEMENT_DEBUG
+
+namespace cv
+{
+//retina classes that derivate from the Basic Retrina class
+class ParvoRetinaFilter: public BasicRetinaFilter
+{
+
+public:
+	/**
+	* constructor parameters are only linked to image input size
+	* @param NBrows: number of rows of the input image
+	* @param NBcolumns: number of columns of the input image
+	*/
+	ParvoRetinaFilter(const unsigned int NBrows=480, const unsigned int NBcolumns=640);
+
+	/**
+	* standard desctructor
+	*/
+	virtual ~ParvoRetinaFilter();
+
+	/**
+	* resize method, keeps initial parameters, all buffers are flushed
+	* @param NBrows: number of rows of the input image
+	* @param NBcolumns: number of columns of the input image
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+	/**
+	* function that clears all buffers of the object
+	*/
+	void clearAllBuffers();
+
+	/**
+	* setup the OPL and IPL parvo channels
+	* @param beta1: gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, the amplitude is boosted but it should only be used for values rescaling... if needed
+	* @param tau1: the time constant of the first order low pass filter of the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is frames, typical value is 1 frame
+	* @param k1: the spatial constant of the first order low pass filter of the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is pixels, typical value is 1 pixel
+	* @param beta2: gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, then, the luminance is not filtered and is still reachable at the output, typicall value is 0
+	* @param tau2: the time constant of the first order low pass filter of the horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is frames, typical value is 1 frame, as the photoreceptors
+	* @param k2: the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel, this value is also used for local contrast computing when computing the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular channel model)
+	*/
+	void setOPLandParvoFiltersParameters(const double beta1, const double tau1, const double k1, const double beta2, const double tau2, const double k2);
+
+	/**
+	* setup more precisely the low pass filter used for the ganglion cells low pass filtering (used for local luminance adaptation)
+	* @param tau: time constant of the filter (unit is frame for video processing)
+	* @param k: spatial constant of the filter (unit is pixels)
+	*/
+	void setGanglionCellsLocalAdaptationLPfilterParameters(const double tau, const double k){BasicRetinaFilter::setLPfilterParameters(0, tau, k, 2);}; // change the parameters of the filter
+
+
+	/**
+	* launch filter that runs the OPL spatiotemporal filtering and optionally finalizes IPL Pagno filter (model of the Parvocellular channel of the Inner Plexiform Layer of the retina)
+	* @param inputFrame: the input image to be processed, this can be the direct gray level input frame, but a better efficacy is expected if the input is preliminary processed by the photoreceptors local adaptation possible to acheive with the help of a BasicRetinaFilter object
+	* @param useParvoOutput: set true if the final IPL filtering step has to be computed (local contrast enhancement)
+	* @return the processed Parvocellular channel output (updated only if useParvoOutput is true)
+	* @details: in any case, after this function call, photoreceptors and horizontal cells output are updated, use getPhotoreceptorsLPfilteringOutput() and getHorizontalCellsOutput() to get them
+	* also, bipolar cells output are accessible (difference between photoreceptors and horizontal cells, ON output has positive values, OFF ouput has negative values), use the following access methods: getBipolarCellsON() and getBipolarCellsOFF()if useParvoOutput is true,
+	* if useParvoOutput is true, the complete Parvocellular channel is computed, more outputs are updated and can be accessed threw: getParvoON(), getParvoOFF() and their difference with getOutput()
+	*/
+	const std::valarray<double> &runFilter(const std::valarray<double> &inputFrame, const bool useParvoOutput=true); // output return is _parvocellularOutputONminusOFF
+
+	/**
+	* @return the output of the photoreceptors filtering step (high cut frequency spatio-temporal low pass filter)
+	*/
+	inline const std::valarray<double> &getPhotoreceptorsLPfilteringOutput() const {return _photoreceptorsOutput;};
+
+	/**
+	* @return the output of the photoreceptors filtering step (low cut frequency spatio-temporal low pass filter)
+	*/
+	inline const std::valarray<double> &getHorizontalCellsOutput() const { return _horizontalCellsOutput;};
+
+	/**
+	* @return the output Parvocellular ON channel of the retina model
+	*/
+	inline const std::valarray<double> &getParvoON() const {return _parvocellularOutputON;};
+
+	/**
+	* @return the output Parvocellular OFF channel of the retina model
+	*/
+	inline const std::valarray<double> &getParvoOFF() const {return _parvocellularOutputOFF;};
+
+	/**
+	* @return the output of the Bipolar cells of the ON channel of the retina model same as function getParvoON() but without luminance local adaptation
+	*/
+	inline const std::valarray<double> &getBipolarCellsON() const {return _bipolarCellsOutputON;};
+
+	/**
+	* @return the output of the Bipolar cells of the OFF channel of the retina model same as function getParvoON() but without luminance local adaptation
+	*/
+	inline const std::valarray<double> &getBipolarCellsOFF() const {return _bipolarCellsOutputOFF;};
+
+	/**
+	* @return the photoreceptors's temporal constant
+	*/
+	inline const double getPhotoreceptorsTemporalConstant(){return this->_filteringCoeficientsTable[2];};
+
+	/**
+	* @return the horizontal cells' temporal constant
+	*/
+	inline const double getHcellsTemporalConstant(){return this->_filteringCoeficientsTable[5];};
+
+private:
+	// template buffers
+	std::valarray <double>_photoreceptorsOutput;
+	std::valarray <double>_horizontalCellsOutput;
+	std::valarray <double>_parvocellularOutputON;
+	std::valarray <double>_parvocellularOutputOFF;
+	std::valarray <double>_bipolarCellsOutputON;
+	std::valarray <double>_bipolarCellsOutputOFF;
+	std::valarray <double>_localAdaptationOFF;
+	std::valarray <double> *_localAdaptationON;
+	TemplateBuffer<double> *_parvocellularOutputONminusOFF;
+	// private functions
+	void _OPL_OnOffWaysComputing();
+
+};
+}
+#endif
+
diff --git a/modules/contrib/src/precomp.hpp b/modules/contrib/src/precomp.hpp
index aab2c8fa66..1f0ef9b063 100644
--- a/modules/contrib/src/precomp.hpp
+++ b/modules/contrib/src/precomp.hpp
@@ -58,4 +58,14 @@
 #include "opencv2/imgproc/imgproc_c.h"
 #include "opencv2/core/internal.hpp"
 
+namespace cv
+{
+
+// special function to get pointer to constant valarray elements, since
+// simple &arr[0] does not compile on VS2005/VS2008.
+template<typename T> inline const T* get_data(const std::valarray<T>& arr)
+{ return &((std::valarray<T>&)arr)[0]; }
+
+}
+
 #endif
diff --git a/modules/contrib/src/retina.cpp b/modules/contrib/src/retina.cpp
new file mode 100644
index 0000000000..faa9b46629
--- /dev/null
+++ b/modules/contrib/src/retina.cpp
@@ -0,0 +1,409 @@
+/*#******************************************************************************
+ ** 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.
+ **
+ **
+ ** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+ ** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+ **
+ ** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+ **
+ **  Creation - enhancement process 2007-2011
+ **      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+ **
+ ** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+ ** Refer to the following research paper for more information:
+ ** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+ ** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+ ** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+ **
+ ** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+ ** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+ ** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+ ** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+ ** ====> more informations in the above cited Jeanny Heraults's book.
+ **
+ **                          License Agreement
+ **               For Open Source Computer Vision Library
+ **
+ ** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+ ** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+ **
+ **               For Human Visual System tools (hvstools)
+ ** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+ **
+ ** Third party copyrights are property of their respective owners.
+ **
+ ** Redistribution and use in source and binary forms, with or without modification,
+ ** are permitted provided that the following conditions are met:
+ **
+ ** * Redistributions of source code must retain the above copyright notice,
+ **    this list of conditions and the following disclaimer.
+ **
+ ** * Redistributions in binary form must reproduce the above copyright notice,
+ **    this list of conditions and the following disclaimer in the documentation
+ **    and/or other materials provided with the distribution.
+ **
+ ** * 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.
+ *******************************************************************************/
+
+/*
+ * Retina.cpp
+ *
+ *  Created on: Jul 19, 2011
+ *      Author: Alexandre Benoit
+ */
+#include "precomp.hpp"
+#include "retinafilter.hpp"
+#include <iostream>
+
+namespace cv
+{
+    
+Retina::Retina(const std::string parametersSaveFile, const cv::Size inputSize)
+{
+	_retinaFilter = 0;
+    _init(parametersSaveFile, inputSize, true, RETINA_COLOR_BAYER, false);
+}
+
+Retina::Retina(const std::string parametersSaveFile, const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
+{
+    _retinaFilter = 0;
+	_init(parametersSaveFile, inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+};
+    
+Retina::~Retina()
+{
+    delete _retinaFilter;
+}
+
+void Retina::setup(std::string retinaParameterFile, const bool applyDefaultSetupOnFailure)
+{
+	// open specified parameters file
+	std::cout<<"Retina::setup: setting up retina from parameter file : "<<retinaParameterFile<<std::endl;
+
+	// very UGLY cases processing... to be updated...
+
+	try
+	{
+
+		// rewriting a new parameter file...
+		if (_parametersSaveFile.isOpened())
+			_parametersSaveFile.release();
+		_parametersSaveFile.open(_parametersSaveFileName, cv::FileStorage::WRITE);
+		// opening retinaParameterFile in read mode
+		cv::FileStorage fs(retinaParameterFile, cv::FileStorage::READ);
+		// read parameters file if it exists or apply default setup if asked for
+		if (!fs.isOpened())
+		{
+			std::cout<<"Retina::setup: provided parameters file could not be open... skeeping configuration"<<std::endl;
+			return;
+			// implicit else case : retinaParameterFile could be open (it exists at least)
+		}
+
+		// preparing parameter setup
+		bool colorMode, normaliseOutput;
+		double photoreceptorsLocalAdaptationSensitivity, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, hcellsTemporalConstant, hcellsSpatialConstant, ganglionCellsSensitivity;
+		// OPL and Parvo init first
+		cv::FileNode rootFn = fs.root(), currFn=rootFn["OPLandIPLparvo"];
+		currFn["colorMode"]>>colorMode;
+		currFn["normaliseOutput"]>>normaliseOutput;
+		currFn["photoreceptorsLocalAdaptationSensitivity"]>>photoreceptorsLocalAdaptationSensitivity;
+		currFn["photoreceptorsTemporalConstant"]>>photoreceptorsTemporalConstant;
+		currFn["photoreceptorsSpatialConstant"]>>photoreceptorsSpatialConstant;
+		currFn["horizontalCellsGain"]>>horizontalCellsGain;
+		currFn["hcellsTemporalConstant"]>>hcellsTemporalConstant;
+		currFn["hcellsSpatialConstant"]>>hcellsSpatialConstant;
+		currFn["ganglionCellsSensitivity"]>>ganglionCellsSensitivity;
+		setupOPLandIPLParvoChannel(colorMode, normaliseOutput, photoreceptorsLocalAdaptationSensitivity, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, hcellsTemporalConstant, hcellsSpatialConstant, ganglionCellsSensitivity);
+
+		// init retina IPL magno setup
+		currFn=rootFn["IPLmagno"];
+		currFn["normaliseOutput"]>>normaliseOutput;
+		double parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k;
+		currFn["parasolCells_beta"]>>parasolCells_beta;
+		currFn["parasolCells_tau"]>>parasolCells_tau;
+		currFn["parasolCells_k"]>>parasolCells_k;
+		currFn["amacrinCellsTemporalCutFrequency"]>>amacrinCellsTemporalCutFrequency;
+		currFn["V0CompressionParameter"]>>V0CompressionParameter;
+		currFn["localAdaptintegration_tau"]>>localAdaptintegration_tau;
+		currFn["localAdaptintegration_k"]>>localAdaptintegration_k;
+
+		setupIPLMagnoChannel(normaliseOutput, parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency,
+				V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k);
+
+	}catch(Exception &e)
+	{
+		std::cout<<"Retina::setup: resetting retina with default parameters"<<std::endl;
+		if (applyDefaultSetupOnFailure)
+		{
+			setupOPLandIPLParvoChannel();
+			setupIPLMagnoChannel();
+		}
+		std::cout<<"Retina::setup: wrong/unappropriate xml parameter file : error report :`n=>"<<e.what()<<std::endl;
+		std::cout<<"=> keeping current parameters"<<std::endl;
+	}
+	_parametersSaveFile.release(); // close file after setup
+	// report current configuration
+	std::cout<<printSetup()<<std::endl;
+}
+
+const std::string Retina::printSetup()
+{
+	std::stringstream outmessage;
+
+
+	try
+	{
+		cv::FileStorage parametersReader(_parametersSaveFileName, cv::FileStorage::READ);
+		if (!parametersReader.isOpened())
+		{
+			outmessage<<"Retina is not already settled up";
+		}
+		else
+		{
+			// accessing xml parameters nodes
+			cv::FileNode rootFn = parametersReader.root();
+			cv::FileNode currFn=rootFn["OPLandIPLparvo"];
+
+			// displaying OPL and IPL parvo setup
+			outmessage<<"Current Retina instance setup :"
+					<<"\nOPLandIPLparvo"<<"{"
+					<< "\n==> colorMode : " << currFn["colorMode"].operator int()
+					<< "\n==> normalizeParvoOutput :" << currFn["normaliseOutput"].operator int()
+					<< "\n==> photoreceptorsLocalAdaptationSensitivity : " << currFn["photoreceptorsLocalAdaptationSensitivity"].operator float()
+					<< "\n==> photoreceptorsTemporalConstant : " << currFn["photoreceptorsTemporalConstant"].operator float()
+					<< "\n==> photoreceptorsSpatialConstant : " << currFn["photoreceptorsSpatialConstant"].operator float()
+					<< "\n==> horizontalCellsGain : " << currFn["horizontalCellsGain"].operator float()
+					<< "\n==> hcellsTemporalConstant : " << currFn["hcellsTemporalConstant"].operator float()
+					<< "\n==> hcellsSpatialConstant : " << currFn["hcellsSpatialConstant"].operator float()
+					<< "\n==> parvoGanglionCellsSensitivity : " << currFn["ganglionCellsSensitivity"].operator float()
+					<<"}\n";
+
+			// displaying IPL magno setup
+			currFn=rootFn["IPLmagno"];
+			outmessage<<"Current Retina instance setup :"
+					<<"\nIPLmagno"<<"{"
+					<< "\n==> normaliseOutput : " << currFn["normaliseOutput"].operator int()
+					<< "\n==> parasolCells_beta : " << currFn["parasolCells_beta"].operator float()
+					<< "\n==> parasolCells_tau : " << currFn["parasolCells_tau"].operator float()
+					<< "\n==> parasolCells_k : " << currFn["parasolCells_k"].operator float()
+					<< "\n==> amacrinCellsTemporalCutFrequency : " << currFn["amacrinCellsTemporalCutFrequency"].operator float()
+					<< "\n==> V0CompressionParameter : " << currFn["V0CompressionParameter"].operator float()
+					<< "\n==> localAdaptintegration_tau : " << currFn["localAdaptintegration_tau"].operator float()
+					<< "\n==> localAdaptintegration_k : " << currFn["localAdaptintegration_k"].operator float()
+					<<"}";
+		}
+	}catch(cv::Exception &e)
+	{
+		outmessage<<"Error reading parameters configuration file : "<<e.what()<<std::endl;
+	}
+	return outmessage.str();
+}
+
+void Retina::setupOPLandIPLParvoChannel(const bool colorMode, const bool normaliseOutput, const double photoreceptorsLocalAdaptationSensitivity, const double photoreceptorsTemporalConstant, const double photoreceptorsSpatialConstant, const double horizontalCellsGain, const double HcellsTemporalConstant, const double HcellsSpatialConstant, const double ganglionCellsSensitivity)
+{
+	// parameters setup (default setup)
+	_retinaFilter->setColorMode(colorMode);
+	_retinaFilter->setPhotoreceptorsLocalAdaptationSensitivity(photoreceptorsLocalAdaptationSensitivity);
+	_retinaFilter->setOPLandParvoParameters(0, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, HcellsTemporalConstant, HcellsSpatialConstant, ganglionCellsSensitivity);
+	_retinaFilter->setParvoGanglionCellsLocalAdaptationSensitivity(ganglionCellsSensitivity);
+	_retinaFilter->activateNormalizeParvoOutput_0_maxOutputValue(normaliseOutput);
+
+	// save parameters in the xml parameters tree... if parameters file is already open
+	if (!_parametersSaveFile.isOpened())
+		return;
+	_parametersSaveFile<<"OPLandIPLparvo"<<"{";
+	_parametersSaveFile << "colorMode" << colorMode;
+	_parametersSaveFile << "normaliseOutput" << normaliseOutput;
+	_parametersSaveFile << "photoreceptorsLocalAdaptationSensitivity" << photoreceptorsLocalAdaptationSensitivity;
+	_parametersSaveFile << "photoreceptorsTemporalConstant" << photoreceptorsTemporalConstant;
+	_parametersSaveFile << "photoreceptorsSpatialConstant" << photoreceptorsSpatialConstant;
+	_parametersSaveFile << "horizontalCellsGain" << horizontalCellsGain;
+	_parametersSaveFile << "hcellsTemporalConstant" << HcellsTemporalConstant;
+	_parametersSaveFile << "hcellsSpatialConstant" << HcellsSpatialConstant;
+	_parametersSaveFile << "ganglionCellsSensitivity" << ganglionCellsSensitivity;
+	_parametersSaveFile << "}";
+}
+
+void Retina::setupIPLMagnoChannel(const bool normaliseOutput, const double parasolCells_beta, const double parasolCells_tau, const double parasolCells_k, const double amacrinCellsTemporalCutFrequency, const double V0CompressionParameter, const double localAdaptintegration_tau, const double localAdaptintegration_k)
+{
+
+	_retinaFilter->setMagnoCoefficientsTable(parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k);
+	_retinaFilter->activateNormalizeMagnoOutput_0_maxOutputValue(normaliseOutput);
+
+	// save parameters in the xml parameters tree... if parameters file is already open
+	if (!_parametersSaveFile.isOpened())
+		return;
+	_parametersSaveFile<<"IPLmagno"<<"{";
+	_parametersSaveFile << "normaliseOutput" << normaliseOutput;
+	_parametersSaveFile << "parasolCells_beta" << parasolCells_beta;
+	_parametersSaveFile << "parasolCells_tau" << parasolCells_tau;
+	_parametersSaveFile << "parasolCells_k" << parasolCells_k;
+	_parametersSaveFile << "amacrinCellsTemporalCutFrequency" << amacrinCellsTemporalCutFrequency;
+	_parametersSaveFile << "V0CompressionParameter" << V0CompressionParameter;
+	_parametersSaveFile << "localAdaptintegration_tau" << localAdaptintegration_tau;
+	_parametersSaveFile << "localAdaptintegration_k" << localAdaptintegration_k;
+	_parametersSaveFile<<"}";
+
+}
+
+void Retina::run(const cv::Mat &inputImage)
+{
+
+	// first check input consistency
+	if (inputImage.empty())
+		throw cv::Exception(-1, "Retina cannot be applied, input buffer is empty", "Retina::run", "Retina.h", 0);
+
+	// retreive color mode from image input
+	bool colorMode = inputImage.channels() >=3;
+
+	// TODO : ensure input color image is CV_BGR coded
+	//if (inputImage.flags!=CV_BGR)
+	//   throw cv::Exception(-1, "Retina color input must be BGR coded", "Retina::run", "Retina.h", 0);
+
+	// first convert input image to the compatible format : std::valarray<double>
+	double *imagePTR=&_inputBuffer[0];
+
+	if (!colorMode)
+	{
+		for (int i=0;i<inputImage.size().height;++i)
+		{
+			const unsigned char *linePTR = inputImage.ptr<unsigned char>(i);
+			for (int j=0;j<inputImage.size().width;++j)
+				*(imagePTR++) =(double)*(linePTR++);
+		}
+	}else
+	{
+		const unsigned int doubleNBpixelsPerLayer=_retinaFilter->getInputNBpixels()*2;
+		for (int i=0;i<inputImage.size().height;++i)
+		{
+			for (int j=0;j<inputImage.size().width;++j,++imagePTR)
+			{
+				cv::Point2d pixel(j,i);
+				cv::Vec3b pixelValue=inputImage.at<cv::Vec3b>(pixel);
+				*(imagePTR) =(double)pixelValue[2];
+				*(imagePTR+_retinaFilter->getInputNBpixels()) =(double)pixelValue[1];
+				*(imagePTR+doubleNBpixelsPerLayer           ) =(double)pixelValue[0];
+			}
+		}
+	}
+
+	// process the retina
+	if (!_retinaFilter->runFilter(_inputBuffer, colorMode, false, colorMode, false))
+		throw cv::Exception(-1, "Retina cannot be applied, wrong input buffer size", "Retina::run", "Retina.h", 0);
+}
+
+void Retina::getParvo(cv::Mat &retinaOutput_parvo)
+{
+	if (_retinaFilter->getColorMode())
+	{
+		// reallocate output buffer (if necessary)
+		_convertValarrayGrayBuffer2cvMat(_retinaFilter->getColorOutput(), _retinaFilter->getOutputNBrows(), _retinaFilter->getOutputNBcolumns(), true, retinaOutput_parvo);
+	}else
+	{
+		// reallocate output buffer (if necessary)
+		_convertValarrayGrayBuffer2cvMat(_retinaFilter->getContours(), _retinaFilter->getOutputNBrows(), _retinaFilter->getOutputNBcolumns(), false, retinaOutput_parvo);
+	}
+	//retinaOutput_parvo/=255.0;
+}
+void Retina::getMagno(cv::Mat &retinaOutput_magno)
+{
+	// reallocate output buffer (if necessary)
+	_convertValarrayGrayBuffer2cvMat(_retinaFilter->getMovingContours(), _retinaFilter->getOutputNBrows(), _retinaFilter->getOutputNBcolumns(), false, retinaOutput_magno);
+	//retinaOutput_magno/=255.0;
+}
+
+// private method called by constructirs
+void Retina::_init(const std::string parametersSaveFile, const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
+{
+	_parametersSaveFileName = parametersSaveFile;
+
+	// basic error check
+	if (inputSize.height*inputSize.width <= 0)
+		throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "Retina::setup", "Retina.h", 0);
+
+	unsigned int nbPixels=inputSize.height*inputSize.width;
+	// resize buffers if size does not match
+	_inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...)
+
+	// allocate the retina model
+    delete _retinaFilter;
+	_retinaFilter = new RetinaFilter(inputSize.height, inputSize.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
+
+	// prepare the parameter XML tree
+	_parametersSaveFile.open(parametersSaveFile, cv::FileStorage::WRITE );
+
+	_parametersSaveFile<<"InputSize"<<"{";
+	_parametersSaveFile<<"height"<<inputSize.height;
+	_parametersSaveFile<<"width"<<inputSize.width;
+	_parametersSaveFile<<"}";
+
+	// clear all retina buffers
+	// apply default setup
+	setupOPLandIPLParvoChannel();
+	setupIPLMagnoChannel();
+
+	// write current parameters to params file
+	_parametersSaveFile.release();
+
+	// init retina
+	_retinaFilter->clearAllBuffers();
+
+	// report current configuration
+	std::cout<<printSetup()<<std::endl;
+}
+
+void Retina::_convertValarrayGrayBuffer2cvMat(const std::valarray<double> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, cv::Mat &outBuffer)
+{
+	// fill output buffer with the valarray buffer
+	const double *valarrayPTR=get_data(grayMatrixToConvert);
+	if (!colorMode)
+	{
+		outBuffer.create(cv::Size(nbColumns, nbRows), CV_8U);
+		for (unsigned int i=0;i<nbRows;++i)
+		{
+			for (unsigned int j=0;j<nbColumns;++j)
+			{
+				cv::Point2d pixel(j,i);
+				outBuffer.at<unsigned char>(pixel)=(unsigned char)*(valarrayPTR++);
+			}
+		}
+	}else
+	{
+		const unsigned int doubleNBpixels=_retinaFilter->getOutputNBpixels()*2;
+		outBuffer.create(cv::Size(nbColumns, nbRows), CV_8UC3);
+		for (unsigned int i=0;i<nbRows;++i)
+		{
+			for (unsigned int j=0;j<nbColumns;++j,++valarrayPTR)
+			{
+				cv::Point2d pixel(j,i);
+				cv::Vec3b pixelValues;
+				pixelValues[2]=(unsigned char)*(valarrayPTR);
+				pixelValues[1]=(unsigned char)*(valarrayPTR+_retinaFilter->getOutputNBpixels());
+				pixelValues[0]=(unsigned char)*(valarrayPTR+doubleNBpixels);
+
+				outBuffer.at<cv::Vec3b>(pixel)=pixelValues;
+			}
+		}
+	}
+}
+
+void Retina::clearBuffers() {_retinaFilter->clearAllBuffers();}
+
+} // end of namespace cv
diff --git a/modules/contrib/src/retinacolor.cpp b/modules/contrib/src/retinacolor.cpp
new file mode 100644
index 0000000000..403dab4774
--- /dev/null
+++ b/modules/contrib/src/retinacolor.cpp
@@ -0,0 +1,744 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+
+#include "retinacolor.hpp"
+
+// @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+
+#include <iostream>
+#include <ctime>
+
+namespace cv
+{
+
+// init static values
+static double _LMStoACr1Cr2[]={1.0,  1.0, 0.0,  1.0, -1.0, 0.0,  -0.5, -0.5, 1.0};
+//static double _ACr1Cr2toLMS[]={0.5,  0.5, 0.0,   0.5, -0.5, 0.0,  0.5,  0.0, 1.0};
+static double _LMStoLab[]={0.5774, 0.5774, 0.5774, 0.4082, 0.4082, -0.8165, 0.7071, -0.7071, 0.0};
+
+// constructor/desctructor
+RetinaColor::RetinaColor(const unsigned int NBrows, const unsigned int NBcolumns, const RETINA_COLORSAMPLINGMETHOD samplingMethod)
+:BasicRetinaFilter(NBrows, NBcolumns, 3),
+ _colorSampling(NBrows*NBcolumns),
+ _RGBmosaic(NBrows*NBcolumns*3),
+ _tempMultiplexedFrame(NBrows*NBcolumns),
+ _demultiplexedTempBuffer(NBrows*NBcolumns*3),
+ _demultiplexedColorFrame(NBrows*NBcolumns*3),
+ _chrominance(NBrows*NBcolumns*3),
+ _colorLocalDensity(NBrows*NBcolumns*3),
+ _imageGradient(NBrows*NBcolumns*3)
+{
+	// link to parent buffers (let's recycle !)
+	_luminance=&_filterOutput;
+	_multiplexedFrame=&_localBuffer;
+
+	_objectInit=false;
+	_samplingMethod=samplingMethod;
+	_saturateColors=false;
+	_colorSaturationValue=4.0;
+
+	// set default spatio-temporal filter parameters
+	setLPfilterParameters(0.0, 0.0, 1.5);
+	setLPfilterParameters(0.0, 0.0, 10.5, 1);// for the low pass filter dedicated to contours energy extraction (demultiplexing process)
+	setLPfilterParameters(0.0, 0.0, 0.9, 2);
+
+	// init default value on image Gradient
+	_imageGradient=0.57;
+
+	// init color sampling map
+	_initColorSampling();
+
+	// flush all buffers
+	clearAllBuffers();
+}
+
+RetinaColor::~RetinaColor()
+{
+
+}
+
+/**
+* function that clears all buffers of the object
+*/
+void RetinaColor::clearAllBuffers()
+{
+	BasicRetinaFilter::clearAllBuffers();
+	_tempMultiplexedFrame=0;
+	_demultiplexedTempBuffer=0;
+
+	_demultiplexedColorFrame=0;
+	_chrominance=0;
+	_imageGradient=1;
+}
+
+/**
+* resize retina color filter object (resize all allocated buffers)
+* @param NBrows: the new height size
+* @param NBcolumns: the new width size
+*/
+void RetinaColor::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+	BasicRetinaFilter::clearAllBuffers();
+	_colorSampling.resize(NBrows*NBcolumns);
+	_RGBmosaic.resize(NBrows*NBcolumns*3);
+	_tempMultiplexedFrame.resize(NBrows*NBcolumns);
+	_demultiplexedTempBuffer.resize(NBrows*NBcolumns*3);
+	_demultiplexedColorFrame.resize(NBrows*NBcolumns*3);
+	_chrominance.resize(NBrows*NBcolumns*3);
+	_colorLocalDensity.resize(NBrows*NBcolumns*3);
+	_imageGradient.resize(NBrows*NBcolumns*3);
+
+	// link to parent buffers (let's recycle !)
+	_luminance=&_filterOutput;
+	_multiplexedFrame=&_localBuffer;
+
+	// init color sampling map
+	_initColorSampling();
+
+	// clean buffers
+	clearAllBuffers();
+}
+
+
+void RetinaColor::_initColorSampling()
+{
+
+	// filling the conversion table for multiplexed <=> demultiplexed frame
+	srand(time(NULL));
+
+	// preInit cones probabilities
+	_pR=_pB=_pG=0;
+	switch (_samplingMethod)
+	{
+	case RETINA_COLOR_RANDOM:
+		for (unsigned int index=0 ; index<this->getNBpixels(); ++index)
+		{
+
+			// random RGB sampling
+			unsigned int colorIndex=rand()%24;
+
+			if (colorIndex<8){
+				colorIndex=0;
+
+				++_pR;
+			}else
+			{
+				if (colorIndex<21){
+					colorIndex=1;
+					++_pG;
+				}else{
+					colorIndex=2;
+					++_pB;
+				}
+			}
+			_colorSampling[index] = colorIndex*this->getNBpixels()+index;
+		}
+		_pR/=(double)this->getNBpixels();
+		_pG/=(double)this->getNBpixels();
+		_pB/=(double)this->getNBpixels();
+		std::cout<<"Color channels proportions: pR, pG, pB= "<<_pR<<", "<<_pG<<", "<<_pB<<", "<<std::endl;
+		break;
+	case RETINA_COLOR_DIAGONAL:
+		for (unsigned int index=0 ; index<this->getNBpixels(); ++index)
+		{
+			_colorSampling[index] = index+((index%3+(index%_filterOutput.getNBcolumns()))%3)*_filterOutput.getNBpixels();
+		}
+		_pR=_pB=_pG=1.0/3.0;
+		break;
+	case RETINA_COLOR_BAYER: // default sets bayer sampling
+		for (unsigned int index=0 ; index<_filterOutput.getNBpixels(); ++index)
+		{
+			//First line: R G R G
+			_colorSampling[index] = index+((index/_filterOutput.getNBcolumns())%2)*_filterOutput.getNBpixels()+((index%_filterOutput.getNBcolumns())%2)*_filterOutput.getNBpixels();
+			//First line: G R G R
+			//_colorSampling[index] = 3*index+((index/_filterOutput.getNBcolumns())%2)+((index%_filterOutput.getNBcolumns()+1)%2);
+		}
+		_pR=_pB=0.25;
+		_pG=0.5;
+		break;
+	default:
+#ifdef RETINACOLORDEBUG
+		std::cerr<<"RetinaColor::No or wrong color sampling method, skeeping"<<std::endl;
+#endif
+		return;
+		break;//.. not useful, yes
+
+	}
+	// feeling the mosaic buffer:
+	_RGBmosaic=0;
+	for (unsigned int index=0 ; index<_filterOutput.getNBpixels(); ++index)
+		// the RGB _RGBmosaic buffer contains 1 where the pixel corresponds to a sampled color
+		_RGBmosaic[_colorSampling[index]]=1.0;
+
+	// computing photoreceptors local density
+	_spatiotemporalLPfilter(&_RGBmosaic[0], &_colorLocalDensity[0]);
+	_spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getNBpixels(), &_colorLocalDensity[0]+_filterOutput.getNBpixels());
+	_spatiotemporalLPfilter(&_RGBmosaic[0]+_filterOutput.getDoubleNBpixels(), &_colorLocalDensity[0]+_filterOutput.getDoubleNBpixels());
+	unsigned int maxNBpixels=3*_filterOutput.getNBpixels();
+	register double *colorLocalDensityPTR=&_colorLocalDensity[0];
+	for (unsigned int i=0;i<maxNBpixels;++i, ++colorLocalDensityPTR)
+		*colorLocalDensityPTR=1.0/ *colorLocalDensityPTR;
+
+#ifdef RETINACOLORDEBUG
+	std::cout<<"INIT 	_colorLocalDensity max, min: "<<_colorLocalDensity.max()<<", "<<_colorLocalDensity.min()<<std::endl;
+#endif
+	// end of the init step
+	_objectInit=true;
+}
+
+// public functions
+
+void RetinaColor::runColorDemultiplexing(const std::valarray<double> &multiplexedColorFrame, const bool adaptiveFiltering, const double maxInputValue)
+{
+	// demultiplex the grey frame to RGB frame
+	// -> first set demultiplexed frame to 0
+	_demultiplexedTempBuffer=0;
+	// -> demultiplex process
+	register unsigned int *colorSamplingPRT=&_colorSampling[0];
+	register const double *multiplexedColorFramePTR=get_data(multiplexedColorFrame);
+	for (unsigned int indexa=0; indexa<_filterOutput.getNBpixels() ; ++indexa)
+		_demultiplexedTempBuffer[*(colorSamplingPRT++)]=*(multiplexedColorFramePTR++);
+
+	// interpolate the demultiplexed frame depending on the color sampling method
+	if (!adaptiveFiltering)
+		_interpolateImageDemultiplexedImage(&_demultiplexedTempBuffer[0]);
+
+	// low pass filtering the demultiplexed frame
+	_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0], &_chrominance[0]);
+	_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getNBpixels(), &_chrominance[0]+_filterOutput.getNBpixels());
+	_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getDoubleNBpixels(), &_chrominance[0]+_filterOutput.getDoubleNBpixels());
+
+	/*if (_samplingMethod=BAYER)
+	{
+		_applyRIFfilter(_chrominance, _chrominance);
+		_applyRIFfilter(_chrominance+_filterOutput.getNBpixels(), _chrominance+_filterOutput.getNBpixels());
+		_applyRIFfilter(_chrominance+_filterOutput.getDoubleNBpixels(), _chrominance+_filterOutput.getDoubleNBpixels());
+	}*/
+
+	// normalize by the photoreceptors local density and retrieve the local luminance
+	register double *chrominancePTR= &_chrominance[0];
+	register double *colorLocalDensityPTR= &_colorLocalDensity[0];
+	register double *luminance= &(*_luminance)[0];
+	if (!adaptiveFiltering)// compute the gradient on the luminance
+	{
+		if (_samplingMethod==RETINA_COLOR_RANDOM)
+			for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance)
+			{
+				// normalize by photoreceptors density
+				double Cr=*(chrominancePTR)*_colorLocalDensity[indexc];
+				double Cg=*(chrominancePTR+_filterOutput.getNBpixels())*_colorLocalDensity[indexc+_filterOutput.getNBpixels()];
+				double Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels())*_colorLocalDensity[indexc+_filterOutput.getDoubleNBpixels()];
+				*luminance=(Cr+Cg+Cb)*_pG;
+				*(chrominancePTR)=Cr-*luminance;
+				*(chrominancePTR+_filterOutput.getNBpixels())=Cg-*luminance;
+				*(chrominancePTR+_filterOutput.getDoubleNBpixels())=Cb-*luminance;
+			}
+		else
+			for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance)
+			{
+				double Cr=*(chrominancePTR);
+				double Cg=*(chrominancePTR+_filterOutput.getNBpixels());
+				double Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels());
+				*luminance=_pR*Cr+_pG*Cg+_pB*Cb;
+				*(chrominancePTR)=Cr-*luminance;
+				*(chrominancePTR+_filterOutput.getNBpixels())=Cg-*luminance;
+				*(chrominancePTR+_filterOutput.getDoubleNBpixels())=Cb-*luminance;
+			}
+
+		// in order to get the color image, each colored map needs to be added the luminance
+		// -> to do so, compute:  multiplexedColorFrame - remultiplexed chrominances
+		runColorMultiplexing(_chrominance, _tempMultiplexedFrame);
+		//lum = 1/3((f*(ImR))/(f*mR) + (f*(ImG))/(f*mG) + (f*(ImB))/(f*mB));
+		double *luminancePTR= &(*_luminance)[0];
+		chrominancePTR= &_chrominance[0];
+		double *demultiplexedColorFramePTR= &_demultiplexedColorFrame[0];
+		for (unsigned int indexp=0; indexp<_filterOutput.getNBpixels() ; ++indexp, ++luminancePTR, ++chrominancePTR, ++demultiplexedColorFramePTR)
+		{
+			*luminancePTR=(multiplexedColorFrame[indexp]-_tempMultiplexedFrame[indexp]);
+			*(demultiplexedColorFramePTR)=*(chrominancePTR)+*luminancePTR;
+			*(demultiplexedColorFramePTR+_filterOutput.getNBpixels())=*(chrominancePTR+_filterOutput.getNBpixels())+*luminancePTR;
+			*(demultiplexedColorFramePTR+_filterOutput.getDoubleNBpixels())=*(chrominancePTR+_filterOutput.getDoubleNBpixels())+*luminancePTR;
+		}
+
+	}else
+	{
+		register const double *multiplexedColorFramePTR= get_data(multiplexedColorFrame);
+		for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR)
+		{
+			// normalize by photoreceptors density
+			double Cr=*(chrominancePTR)*_colorLocalDensity[indexc];
+			double Cg=*(chrominancePTR+_filterOutput.getNBpixels())*_colorLocalDensity[indexc+_filterOutput.getNBpixels()];
+			double Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels())*_colorLocalDensity[indexc+_filterOutput.getDoubleNBpixels()];
+			*luminance=(Cr+Cg+Cb)*_pG;
+			_demultiplexedTempBuffer[_colorSampling[indexc]] = *multiplexedColorFramePTR - *luminance;
+
+		}
+
+		// compute the gradient of the luminance
+		_computeGradient(&(*_luminance)[0]);
+
+		// adaptively filter the submosaics to get the adaptive densities, here the buffer _chrominance is used as a temp buffer
+		_adaptiveSpatialLPfilter(&_RGBmosaic[0], &_chrominance[0]);
+		_adaptiveSpatialLPfilter(&_RGBmosaic[0]+_filterOutput.getNBpixels(), &_chrominance[0]+_filterOutput.getNBpixels());
+		_adaptiveSpatialLPfilter(&_RGBmosaic[0]+_filterOutput.getDoubleNBpixels(), &_chrominance[0]+_filterOutput.getDoubleNBpixels());
+
+		_adaptiveSpatialLPfilter(&_demultiplexedTempBuffer[0], &_demultiplexedColorFrame[0]);
+		_adaptiveSpatialLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getNBpixels(), &_demultiplexedColorFrame[0]+_filterOutput.getNBpixels());
+		_adaptiveSpatialLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getDoubleNBpixels(), &_demultiplexedColorFrame[0]+_filterOutput.getDoubleNBpixels());
+
+		for (unsigned int index=0; index<_filterOutput.getNBpixels()*3 ; ++index) // cette boucle pourrait �tre supprimee en passant la densit� � la fonction de filtrage
+			_demultiplexedColorFrame[index] /= _chrominance[index];
+
+		// compute and substract the residual luminance
+		for (unsigned int index=0; index<_filterOutput.getNBpixels() ; ++index)
+		{
+			double residu = _pR*_demultiplexedColorFrame[index] + _pG*_demultiplexedColorFrame[index+_filterOutput.getNBpixels()] + _pB*_demultiplexedColorFrame[index+_filterOutput.getDoubleNBpixels()];
+			_demultiplexedColorFrame[index] = _demultiplexedColorFrame[index] - residu;
+			_demultiplexedColorFrame[index+_filterOutput.getNBpixels()] = _demultiplexedColorFrame[index+_filterOutput.getNBpixels()] - residu;
+			_demultiplexedColorFrame[index+_filterOutput.getDoubleNBpixels()] = _demultiplexedColorFrame[index+_filterOutput.getDoubleNBpixels()] - residu;
+		}
+
+		// multiplex the obtained chrominance
+		runColorMultiplexing(_demultiplexedColorFrame, _tempMultiplexedFrame);
+		_demultiplexedTempBuffer=0;
+
+		// get the luminance, et and add it to each chrominance
+		for (unsigned int index=0; index<_filterOutput.getNBpixels() ; ++index)
+		{
+			(*_luminance)[index]=multiplexedColorFrame[index]-_tempMultiplexedFrame[index];
+			_demultiplexedTempBuffer[_colorSampling[index]] = _demultiplexedColorFrame[_colorSampling[index]];//multiplexedColorFrame[index] - (*_luminance)[index];
+		}
+
+		_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0], &_demultiplexedTempBuffer[0]);
+		_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getNBpixels(), &_demultiplexedTempBuffer[0]+_filterOutput.getNBpixels());
+		_spatiotemporalLPfilter(&_demultiplexedTempBuffer[0]+_filterOutput.getDoubleNBpixels(), &_demultiplexedTempBuffer[0]+_filterOutput.getDoubleNBpixels());
+
+		// get the luminance and add it to each chrominance
+		for (unsigned int index=0; index<_filterOutput.getNBpixels() ; ++index)
+		{
+			_demultiplexedColorFrame[index] = _demultiplexedTempBuffer[index]*_colorLocalDensity[index]+ (*_luminance)[index];
+			_demultiplexedColorFrame[index+_filterOutput.getNBpixels()] = _demultiplexedTempBuffer[index+_filterOutput.getNBpixels()]*_colorLocalDensity[index+_filterOutput.getNBpixels()]+ (*_luminance)[index];
+			_demultiplexedColorFrame[index+_filterOutput.getDoubleNBpixels()] = _demultiplexedTempBuffer[index+_filterOutput.getDoubleNBpixels()]*_colorLocalDensity[index+_filterOutput.getDoubleNBpixels()]+ (*_luminance)[index];
+		}
+	}
+
+	// eliminate saturated colors by simple clipping values to the input range
+	clipRGBOutput_0_maxInputValue(NULL, maxInputValue);
+
+	/* transfert image gradient in order to check validity
+    memcpy((*_luminance), _imageGradient, sizeof(double)*_filterOutput.getNBpixels());
+    memcpy(_demultiplexedColorFrame, _imageGradient+_filterOutput.getNBpixels(), sizeof(double)*_filterOutput.getNBpixels());
+    memcpy(_demultiplexedColorFrame+_filterOutput.getNBpixels(), _imageGradient+_filterOutput.getNBpixels(), sizeof(double)*_filterOutput.getNBpixels());
+    memcpy(_demultiplexedColorFrame+2*_filterOutput.getNBpixels(), _imageGradient+_filterOutput.getNBpixels(), sizeof(double)*_filterOutput.getNBpixels());
+	 */
+
+	if (_saturateColors)
+	{
+		TemplateBuffer<double>::normalizeGrayOutputCentredSigmoide(128, _colorSaturationValue, maxInputValue, &_demultiplexedColorFrame[0], &_demultiplexedColorFrame[0], _filterOutput.getNBpixels());
+		TemplateBuffer<double>::normalizeGrayOutputCentredSigmoide(128, _colorSaturationValue, maxInputValue, &_demultiplexedColorFrame[0]+_filterOutput.getNBpixels(), &_demultiplexedColorFrame[0]+_filterOutput.getNBpixels(), _filterOutput.getNBpixels());
+		TemplateBuffer<double>::normalizeGrayOutputCentredSigmoide(128, _colorSaturationValue, maxInputValue, &_demultiplexedColorFrame[0]+_filterOutput.getNBpixels()*2, &_demultiplexedColorFrame[0]+_filterOutput.getNBpixels()*2, _filterOutput.getNBpixels());
+	}
+}
+
+// color multiplexing: input frame size=_NBrows*_filterOutput.getNBcolumns()*3, multiplexedFrame output size=_NBrows*_filterOutput.getNBcolumns()
+void RetinaColor::runColorMultiplexing(const std::valarray<double> &demultiplexedInputFrame, std::valarray<double> &multiplexedFrame)
+{
+	// multiply each color layer by its bayer mask
+	register unsigned int *colorSamplingPTR= &_colorSampling[0];
+	register double *multiplexedFramePTR= &multiplexedFrame[0];
+	for (unsigned int indexp=0; indexp<_filterOutput.getNBpixels(); ++indexp)
+		*(multiplexedFramePTR++)=demultiplexedInputFrame[*(colorSamplingPTR++)];
+}
+
+void RetinaColor::normalizeRGBOutput_0_maxOutputValue(const double maxOutputValue)
+{
+	//normalizeGrayOutputCentredSigmoide(0.0, 2, _chrominance);
+	TemplateBuffer<double>::normalizeGrayOutput_0_maxOutputValue(&_demultiplexedColorFrame[0], 3*_filterOutput.getNBpixels(), maxOutputValue);
+	//normalizeGrayOutputCentredSigmoide(0.0, 2, _chrominance+_filterOutput.getNBpixels());
+	//normalizeGrayOutput_0_maxOutputValue(_demultiplexedColorFrame+_filterOutput.getNBpixels(), _filterOutput.getNBpixels(), maxOutputValue);
+	//normalizeGrayOutputCentredSigmoide(0.0, 2, _chrominance+2*_filterOutput.getNBpixels());
+	//normalizeGrayOutput_0_maxOutputValue(_demultiplexedColorFrame+_filterOutput.getDoubleNBpixels(), _filterOutput.getNBpixels(), maxOutputValue);
+	TemplateBuffer<double>::normalizeGrayOutput_0_maxOutputValue(&(*_luminance)[0], _filterOutput.getNBpixels(), maxOutputValue);
+}
+
+/// normalize output between 0 and maxOutputValue;
+void RetinaColor::clipRGBOutput_0_maxInputValue(double *inputOutputBuffer, const double maxInputValue)
+{
+	//std::cout<<"RetinaColor::normalizing RGB frame..."<<std::endl;
+	// if outputBuffer unsassigned, the rewrite the buffer
+	if (inputOutputBuffer==NULL)
+		inputOutputBuffer= &_demultiplexedColorFrame[0];
+
+	register double *inputOutputBufferPTR=inputOutputBuffer;
+	for (register unsigned int jf = 0; jf < _filterOutput.getNBpixels()*3; ++jf, ++inputOutputBufferPTR)
+	{
+		if (*inputOutputBufferPTR>maxInputValue)
+			*inputOutputBufferPTR=maxInputValue;
+		else if (*inputOutputBufferPTR<0)
+			*inputOutputBufferPTR=0;
+	}
+	//std::cout<<"RetinaColor::...normalizing RGB frame OK"<<std::endl;
+}
+
+void RetinaColor::_interpolateImageDemultiplexedImage(double *inputOutputBuffer)
+{
+
+	switch(_samplingMethod)
+	{
+
+	case RETINA_COLOR_RANDOM:
+		return; // no need to interpolate
+		break;
+
+	case RETINA_COLOR_DIAGONAL:
+		_interpolateSingleChannelImage111(inputOutputBuffer);
+		break;
+
+	case RETINA_COLOR_BAYER: // default sets bayer sampling
+		_interpolateBayerRGBchannels(inputOutputBuffer);
+		break;
+	default:
+		std::cerr<<"RetinaColor::No or wrong color sampling method, skeeping"<<std::endl;
+		return;
+		break;//.. not useful, yes
+
+	}
+
+}
+
+void RetinaColor::_interpolateSingleChannelImage111(double *inputOutputBuffer)
+{
+	for (unsigned int indexr=0 ; indexr<_filterOutput.getNBrows(); ++indexr)
+	{
+		for (unsigned int indexc=1 ; indexc<_filterOutput.getNBcolumns()-1; ++indexc)
+		{
+			unsigned int index=indexc+indexr*_filterOutput.getNBcolumns();
+			inputOutputBuffer[index]=(inputOutputBuffer[index-1]+inputOutputBuffer[index]+inputOutputBuffer[index+1])/3.0;
+		}
+	}
+	for (unsigned int indexc=0 ; indexc<_filterOutput.getNBcolumns(); ++indexc)
+	{
+		for (unsigned int indexr=1 ; indexr<_filterOutput.getNBrows()-1; ++indexr)
+		{
+			unsigned int index=indexc+indexr*_filterOutput.getNBcolumns();
+			inputOutputBuffer[index]=(inputOutputBuffer[index-_filterOutput.getNBcolumns()]+inputOutputBuffer[index]+inputOutputBuffer[index+_filterOutput.getNBcolumns()])/3.0;
+		}
+	}
+}
+
+void RetinaColor::_interpolateBayerRGBchannels(double *inputOutputBuffer)
+{
+	for (unsigned int indexr=0 ; indexr<_filterOutput.getNBrows()-1; indexr+=2)
+	{
+		for (unsigned int indexc=1 ; indexc<_filterOutput.getNBcolumns()-1; indexc+=2)
+		{
+			unsigned int indexR=indexc+indexr*_filterOutput.getNBcolumns();
+			unsigned int indexB=_filterOutput.getDoubleNBpixels()+indexc+1+(indexr+1)*_filterOutput.getNBcolumns();
+			inputOutputBuffer[indexR]=(inputOutputBuffer[indexR-1]+inputOutputBuffer[indexR+1])/2.0;
+			inputOutputBuffer[indexB]=(inputOutputBuffer[indexB-1]+inputOutputBuffer[indexB+1])/2.0;
+		}
+	}
+	for (unsigned int indexr=1 ; indexr<_filterOutput.getNBrows()-1; indexr+=2)
+	{
+		for (unsigned int indexc=0 ; indexc<_filterOutput.getNBcolumns(); ++indexc)
+		{
+			unsigned int indexR=indexc+indexr*_filterOutput.getNBcolumns();
+			unsigned int indexB=_filterOutput.getDoubleNBpixels()+indexc+1+(indexr+1)*_filterOutput.getNBcolumns();
+			inputOutputBuffer[indexR]=(inputOutputBuffer[indexR-_filterOutput.getNBcolumns()]+inputOutputBuffer[indexR+_filterOutput.getNBcolumns()])/2.0;
+			inputOutputBuffer[indexB]=(inputOutputBuffer[indexB-_filterOutput.getNBcolumns()]+inputOutputBuffer[indexB+_filterOutput.getNBcolumns()])/2.0;
+
+		}
+	}
+	for (unsigned int indexr=1 ; indexr<_filterOutput.getNBrows()-1; ++indexr)
+		for (unsigned int indexc=0 ; indexc<_filterOutput.getNBcolumns(); indexc+=2)
+		{
+			unsigned int indexG=_filterOutput.getNBpixels()+indexc+(indexr)*_filterOutput.getNBcolumns()+indexr%2;
+			inputOutputBuffer[indexG]=(inputOutputBuffer[indexG-1]+inputOutputBuffer[indexG+1]+inputOutputBuffer[indexG-_filterOutput.getNBcolumns()]+inputOutputBuffer[indexG+_filterOutput.getNBcolumns()])*0.25;
+		}
+}
+
+void RetinaColor::_applyRIFfilter(const double *sourceBuffer, double *destinationBuffer)
+{
+	for (unsigned int indexr=1 ; indexr<_filterOutput.getNBrows()-1; ++indexr)
+	{
+		for (unsigned int indexc=1 ; indexc<_filterOutput.getNBcolumns()-1; ++indexc)
+		{
+			unsigned int index=indexc+indexr*_filterOutput.getNBcolumns();
+			_tempMultiplexedFrame[index]=(4.0*sourceBuffer[index]+sourceBuffer[index-1-_filterOutput.getNBcolumns()]+sourceBuffer[index-1+_filterOutput.getNBcolumns()]+sourceBuffer[index+1-_filterOutput.getNBcolumns()]+sourceBuffer[index+1+_filterOutput.getNBcolumns()])*0.125;
+		}
+	}
+	memcpy(destinationBuffer, &_tempMultiplexedFrame[0], sizeof(double)*_filterOutput.getNBpixels());
+}
+
+void RetinaColor::_getNormalizedContoursImage(const double *inputFrame, double *outputFrame)
+{
+	double maxValue=0;
+	double normalisationFactor=1.0/3.0;
+	for (unsigned int indexr=1 ; indexr<_filterOutput.getNBrows()-1; ++indexr)
+	{
+		for (unsigned int indexc=1 ; indexc<_filterOutput.getNBcolumns()-1; ++indexc)
+		{
+			unsigned int index=indexc+indexr*_filterOutput.getNBcolumns();
+			outputFrame[index]=normalisationFactor*fabs(8.0*inputFrame[index]-inputFrame[index-1]-inputFrame[index+1]-inputFrame[index-_filterOutput.getNBcolumns()]-inputFrame[index+_filterOutput.getNBcolumns()]-inputFrame[index-1-_filterOutput.getNBcolumns()]-inputFrame[index-1+_filterOutput.getNBcolumns()]-inputFrame[index+1-_filterOutput.getNBcolumns()]-inputFrame[index+1+_filterOutput.getNBcolumns()]);
+			if (outputFrame[index]>maxValue)
+				maxValue=outputFrame[index];
+		}
+	}
+	normalisationFactor=1.0/maxValue;
+	// normalisation [0, 1]
+	                  for (unsigned int indexp=1 ; indexp<_filterOutput.getNBrows()-1; ++indexp)
+	                	  outputFrame[indexp]=outputFrame[indexp]*normalisationFactor;
+}
+
+//////////////////////////////////////////////////////////
+//        ADAPTIVE BASIC RETINA FILTER
+//////////////////////////////////////////////////////////
+// run LP filter for a new frame input and save result at a specific output adress
+void RetinaColor::_adaptiveSpatialLPfilter(const double *inputFrame, double *outputFrame)
+{
+
+	/**********/
+	_gain = (1-0.57)*(1-0.57)*(1-0.06)*(1-0.06);
+
+	// launch the serie of 1D directional filters in order to compute the 2D low pass filter
+	_adaptiveHorizontalCausalFilter_addInput(inputFrame, outputFrame, 0, _filterOutput.getNBrows());
+	_adaptiveHorizontalAnticausalFilter(outputFrame, 0, _filterOutput.getNBrows());
+	_adaptiveVerticalCausalFilter(outputFrame, 0, _filterOutput.getNBcolumns());
+	_adaptiveVerticalAnticausalFilter_multGain(outputFrame, 0, _filterOutput.getNBcolumns());
+
+}
+
+//  horizontal causal filter which adds the input inside
+void RetinaColor::_adaptiveHorizontalCausalFilter_addInput(const double *inputFrame, double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register const double* inputPTR=inputFrame+IDrowStart*_filterOutput.getNBcolumns();
+	register double *imageGradientPTR= &_imageGradient[0]+IDrowStart*_filterOutput.getNBcolumns();
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			//std::cout<<(*imageGradientPTR)<<" ";
+			result = *(inputPTR++) + (*imageGradientPTR)* result;
+			*(outputPTR++) = result;
+			++imageGradientPTR;
+		}
+		//        std::cout<<" "<<std::endl;
+	}
+}
+
+//  horizontal anticausal filter  (basic way, no add on)
+void RetinaColor::_adaptiveHorizontalAnticausalFilter(double *outputFrame, unsigned int IDrowStart, unsigned int IDrowEnd)
+{
+	register double* outputPTR=outputFrame+IDrowEnd*(_filterOutput.getNBcolumns())-1;
+	register double *imageGradientPTR= &_imageGradient[0]+IDrowEnd*(_filterOutput.getNBcolumns())-1;
+
+	for (unsigned int IDrow=IDrowStart; IDrow<IDrowEnd; ++IDrow)
+	{
+		register double result=0;
+		for (unsigned int index=0; index<_filterOutput.getNBcolumns(); ++index)
+		{
+			result = *(outputPTR)+  (*imageGradientPTR)* result;
+			*(outputPTR--) = result;
+			--imageGradientPTR;
+		}
+	}
+}
+
+//  vertical anticausal filter
+void RetinaColor::_adaptiveVerticalCausalFilter(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputFrame+IDcolumn;
+		register double *imageGradientPTR= &_imageGradient[0]+IDcolumn;
+
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + (*(imageGradientPTR+_filterOutput.getNBpixels())) * result;
+			*(outputPTR) = result;
+			outputPTR+=_filterOutput.getNBcolumns();
+			imageGradientPTR+=_filterOutput.getNBcolumns();
+
+		}
+	}
+}
+
+//  vertical anticausal filter which multiplies the output by _gain
+void RetinaColor::_adaptiveVerticalAnticausalFilter_multGain(double *outputFrame, unsigned int IDcolumnStart, unsigned int IDcolumnEnd)
+{
+	double* outputOffset=outputFrame+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+	double* gradOffset= &_imageGradient[0]+_filterOutput.getNBpixels()-_filterOutput.getNBcolumns();
+
+	for (unsigned int IDcolumn=IDcolumnStart; IDcolumn<IDcolumnEnd; ++IDcolumn)
+	{
+		register double result=0;
+		register double *outputPTR=outputOffset+IDcolumn;
+		register double *imageGradientPTR=gradOffset+IDcolumn;
+		for (unsigned int index=0; index<_filterOutput.getNBrows(); ++index)
+		{
+			result = *(outputPTR) + (*(imageGradientPTR+_filterOutput.getNBpixels())) * result;
+			*(outputPTR) = _gain*result;
+			outputPTR-=_filterOutput.getNBcolumns();
+			imageGradientPTR-=_filterOutput.getNBcolumns();
+		}
+	}
+}
+
+///////////////////////////
+void RetinaColor::_computeGradient(const double *luminance)
+{
+	for (unsigned int idLine=2;idLine<_filterOutput.getNBrows()-2;++idLine)
+	{
+		for (unsigned int idColumn=2;idColumn<_filterOutput.getNBcolumns()-2;++idColumn)
+		{
+			const unsigned int pixelIndex=idColumn+_filterOutput.getNBcolumns()*idLine;
+
+			// horizontal and vertical local gradients
+			const double verticalGrad=fabs(luminance[pixelIndex+_filterOutput.getNBcolumns()]-luminance[pixelIndex-_filterOutput.getNBcolumns()]);
+			const double horizontalGrad=fabs(luminance[pixelIndex+1]-luminance[pixelIndex-1]);
+
+			// neighborhood horizontal and vertical gradients
+			const double verticalGrad_p=fabs(luminance[pixelIndex]-luminance[pixelIndex-2*_filterOutput.getNBcolumns()]);
+			const double horizontalGrad_p=fabs(luminance[pixelIndex]-luminance[pixelIndex-2]);
+			const double verticalGrad_n=fabs(luminance[pixelIndex+2*_filterOutput.getNBcolumns()]-luminance[pixelIndex]);
+			const double horizontalGrad_n=fabs(luminance[pixelIndex+2]-luminance[pixelIndex]);
+
+			const double horizontalGradient=0.5*horizontalGrad+0.25*(horizontalGrad_p+horizontalGrad_n);
+			const double verticalGradient=0.5*verticalGrad+0.25*(verticalGrad_p+verticalGrad_n);
+
+			// compare local gradient means and fill the appropriate filtering coefficient value that will be used in adaptative filters
+			if (horizontalGradient<verticalGradient)
+			{
+				_imageGradient[pixelIndex+_filterOutput.getNBpixels()]=0.06;
+				_imageGradient[pixelIndex]=0.57;
+			}
+			else
+			{
+				_imageGradient[pixelIndex+_filterOutput.getNBpixels()]=0.57;
+				_imageGradient[pixelIndex]=0.06;
+			}
+		}
+	}
+
+}
+const bool RetinaColor::applyKrauskopfLMS2Acr1cr2Transform(std::valarray<double> &result)
+{
+	bool processSuccess=true;
+	// basic preliminary error check
+	if (result.size()!=_demultiplexedColorFrame.size())
+	{
+		std::cerr<<"RetinaColor::applyKrauskopfLMS2Acr1cr2Transform: input buffer does not match retina buffer size, conversion aborted"<<std::endl;
+		return false;
+	}
+
+	// apply transformation
+	_applyImageColorSpaceConversion(_demultiplexedColorFrame, result, _LMStoACr1Cr2);
+
+	return processSuccess;
+}
+
+const bool RetinaColor::applyLMS2LabTransform(std::valarray<double> &result)
+{
+	bool processSuccess=true;
+	// basic preliminary error check
+	if (result.size()!=_demultiplexedColorFrame.size())
+	{
+		std::cerr<<"RetinaColor::applyKrauskopfLMS2Acr1cr2Transform: input buffer does not match retina buffer size, conversion aborted"<<std::endl;
+		return false;
+	}
+
+	// apply transformation
+	_applyImageColorSpaceConversion(_demultiplexedColorFrame, result, _LMStoLab);
+
+	return processSuccess;
+}
+
+// template function able to perform a custom color space transformation
+void RetinaColor::_applyImageColorSpaceConversion(const std::valarray<double> &inputFrameBuffer, std::valarray<double> &outputFrameBuffer, const double *transformTable)
+{
+	// two step methods in order to allow inputFrame and outputFrame to be the same
+	unsigned int nbPixels=(unsigned int)(inputFrameBuffer.size()/3), dbpixels=(unsigned int)(2*inputFrameBuffer.size()/3);
+
+	const double *inputFrame=get_data(inputFrameBuffer);
+	double *outputFrame= &outputFrameBuffer[0];
+
+	for (unsigned int dataIndex=0; dataIndex<nbPixels;++dataIndex, ++outputFrame, ++inputFrame)
+	{
+		// first step, compute each new values
+		double layer1 = *(inputFrame)**(transformTable+0)  +*(inputFrame+nbPixels)**(transformTable+1)  +*(inputFrame+dbpixels)**(transformTable+2);
+		double layer2 = *(inputFrame)**(transformTable+3)  +*(inputFrame+nbPixels)**(transformTable+4)  +*(inputFrame+dbpixels)**(transformTable+5);
+		double layer3 = *(inputFrame)**(transformTable+6)  +*(inputFrame+nbPixels)**(transformTable+7)  +*(inputFrame+dbpixels)**(transformTable+8);
+		// second, affect the output
+		*(outputFrame)          = layer1;
+		*(outputFrame+nbPixels) = layer2;
+		*(outputFrame+dbpixels) = layer3;
+	}
+}
+
+}
diff --git a/modules/contrib/src/retinacolor.hpp b/modules/contrib/src/retinacolor.hpp
new file mode 100644
index 0000000000..e6e8a7f4c9
--- /dev/null
+++ b/modules/contrib/src/retinacolor.hpp
@@ -0,0 +1,266 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+/**
+* @class RetinaColor a color multilexing/demultiplexing (demosaicing) based on a human vision inspiration. Different mosaicing strategies can be used, included random sampling !
+* => please take a look at the nice and efficient demosaicing strategy introduced by B.Chaix de Lavarene, take a look at the cited paper for more mathematical details
+* @brief Retina color sampling model which allows classical bayer sampling, random and potentially several other method ! Low color errors on corners !
+* -> Based on the research of:
+*		.Brice Chaix Lavarene (chaix@lis.inpg.fr)
+*		.Jeanny Herault (herault@lis.inpg.fr)
+*		.David Alleyson (david.alleyson@upmf-grenoble.fr)
+*      .collaboration: alexandre benoit (benoit.alexandre.vision@gmail.com or benoit@lis.inpg.fr)
+* Please cite: B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC / Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+*/
+
+#ifndef RETINACOLOR_HPP_
+#define RETINACOLOR_HPP_
+
+#include "basicretinafilter.hpp"
+
+//#define __RETINACOLORDEBUG //define RETINACOLORDEBUG in order to display debug data
+
+namespace cv
+{
+
+class RetinaColor: public BasicRetinaFilter
+{
+public:
+	/**
+	* @typedef which allows to select the type of photoreceptors color sampling
+	*/
+
+	/**
+	* constructor of the retina color processing model
+	* @param NBrows: number of rows of the input image
+	* @param NBcolumns: number of columns of the input image
+	* @param samplingMethod: the chosen color sampling method
+	*/
+	RetinaColor(const unsigned int NBrows, const unsigned int NBcolumns, const RETINA_COLORSAMPLINGMETHOD samplingMethod=RETINA_COLOR_DIAGONAL);
+
+	/**
+	* standard destructor
+	*/
+	virtual ~RetinaColor();
+
+	/**
+	* function that clears all buffers of the object
+	*/
+	void clearAllBuffers();
+
+	/**
+	* resize retina color filter object (resize all allocated buffers)
+	* @param NBrows: the new height size
+	* @param NBcolumns: the new width size
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+
+	/**
+	* color multiplexing function: a demultiplexed RGB frame of size M*N*3 is transformed into a multiplexed M*N*1 pixels frame where each pixel is either Red, or Green or Blue
+	* @param inputRGBFrame: the input RGB frame to be processed
+	* @return, nothing but the multiplexed frame is available by the use of the getMultiplexedFrame() function
+	*/
+	inline void runColorMultiplexing(const std::valarray<double> &inputRGBFrame){runColorMultiplexing(inputRGBFrame, *_multiplexedFrame);};
+
+	/**
+	* color multiplexing function: a demultipleed RGB frame of size M*N*3 is transformed into a multiplexed M*N*1 pixels frame where each pixel is either Red, or Green or Blue if using RGB images
+	* @param demultiplexedInputFrame: the demultiplexed input frame to be processed of size M*N*3
+	* @param multiplexedFrame: the resulting multiplexed frame
+	*/
+	void runColorMultiplexing(const std::valarray<double> &demultiplexedInputFrame, std::valarray<double> &multiplexedFrame);
+
+	/**
+	* color demultiplexing function: a multiplexed frame of size M*N*1 pixels is transformed into a RGB demultiplexed M*N*3 pixels frame
+	* @param multiplexedColorFrame: the input multiplexed frame to be processed
+	* @param adaptiveFiltering: specifies if an adaptive filtering has to be perform rather than standard filtering (adaptive filtering allows a better rendering)
+	* @param maxInputValue: the maximum input data value (should be 255 for 8 bits images but it can change in the case of High Dynamic Range Images (HDRI)
+	* @return, nothing but the output demultiplexed frame is available by the use of the getDemultiplexedColorFrame() function, also use getLuminance() and getChrominance() in order to retreive either luminance or chrominance
+	*/
+	void runColorDemultiplexing(const std::valarray<double> &multiplexedColorFrame, const bool adaptiveFiltering=false, const double maxInputValue=255.0);
+
+	/**
+	* activate color saturation as the final step of the color demultiplexing process
+	* -> this saturation is a sigmoide function applied to each channel of the demultiplexed image.
+	* @param saturateColors: boolean that activates color saturation (if true) or desactivate (if false)
+	* @param colorSaturationValue: the saturation factor
+	* */
+	void setColorSaturation(const bool saturateColors=true, const double colorSaturationValue=4.0){_saturateColors=saturateColors; _colorSaturationValue=colorSaturationValue;};
+
+	/**
+	* set parameters of the low pass spatio-temporal filter used to retreive the low chrominance
+	* @param beta: gain of the filter (generally set to zero)
+	* @param tau: time constant of the filter (unit is frame for video processing), typically 0 when considering static processing, 1 or more if a temporal smoothing effect is required
+	* @param k: spatial constant of the filter (unit is pixels), typical value is 2.5
+	*/
+	void setChrominanceLPfilterParameters(const double beta, const double tau, const double k){setLPfilterParameters(beta, tau, k);};
+
+	/**
+	* apply to the retina color output the Krauskopf transformation which leads to an opponent color system: output colorspace if Acr1cr2 if input of the retina was LMS color space
+	* @param result: the input buffer to fill with the transformed colorspace retina output
+	* @return true if process ended successfully
+	*/
+	const bool applyKrauskopfLMS2Acr1cr2Transform(std::valarray<double> &result);
+
+	/**
+	* apply to the retina color output the CIE Lab color transformation
+	* @param result: the input buffer to fill with the transformed colorspace retina output
+	* @return true if process ended successfully
+	*/
+	const bool applyLMS2LabTransform(std::valarray<double> &result);
+
+	/**
+	* @return the multiplexed frame result (use this after function runColorMultiplexing)
+	*/
+	inline const std::valarray<double> &getMultiplexedFrame() const {return *_multiplexedFrame;};
+
+	/**
+	* @return the demultiplexed frame result (use this after function runColorDemultiplexing)
+	*/
+	inline const std::valarray<double> &getDemultiplexedColorFrame() const {return _demultiplexedColorFrame;};
+
+	/**
+	* @return the luminance of the processed frame (use this after function runColorDemultiplexing)
+	*/
+	inline const std::valarray<double> &getLuminance() const {return *_luminance;};
+
+	/**
+	* @return the chrominance of the processed frame (use this after function runColorDemultiplexing)
+	*/
+	inline const std::valarray<double> &getChrominance() const {return _chrominance;};
+
+	/**
+	* standard 0 to 255 image clipping function appled to RGB images (of size M*N*3 pixels)
+	* @param inputOutputBuffer: the image to be normalized (rewrites the input), if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param maxOutputValue: the maximum value allowed at the output (values superior to it would be clipped
+	*/
+	void clipRGBOutput_0_maxInputValue(double *inputOutputBuffer, const double maxOutputValue=255.0);
+
+	/**
+	* standard 0 to 255 image normalization function appled to RGB images (of size M*N*3 pixels)
+	* @param maxOutputValue: the maximum value allowed at the output (values superior to it would be clipped
+	*/
+	void normalizeRGBOutput_0_maxOutputValue(const double maxOutputValue=255.0);
+
+	/**
+	* return the color sampling map: a Nrows*Mcolumns image in which each pixel value is the ofsset adress which gives the adress of the sampled pixel on an Nrows*Mcolumns*3 color image ordered by layers: layer1, layer2, layer3
+	*/
+	inline const std::valarray<unsigned int> &getSamplingMap() const {return _colorSampling;};
+
+	/**
+	* function used (to bypass processing) to manually set the color output
+	* @param demultiplexedImage: the color image (luminance+chrominance) which has to be written in the object buffer
+	*/
+	inline void setDemultiplexedColorFrame(const std::valarray<double> &demultiplexedImage){_demultiplexedColorFrame=demultiplexedImage;};
+
+protected:
+
+	// private functions
+	RETINA_COLORSAMPLINGMETHOD _samplingMethod;
+	bool _saturateColors;
+	double _colorSaturationValue;
+	// links to parent buffers (more convienient names
+	TemplateBuffer<double> *_luminance;
+	std::valarray<double> *_multiplexedFrame;
+	// instance buffers
+	std::valarray<unsigned int> _colorSampling; // table (size (_nbRows*_nbColumns) which specifies the color of each pixel
+	std::valarray<double> _RGBmosaic;
+	std::valarray<double> _tempMultiplexedFrame;
+	std::valarray<double> _demultiplexedTempBuffer;
+	std::valarray<double> _demultiplexedColorFrame;
+	std::valarray<double> _chrominance;
+	std::valarray<double> _colorLocalDensity;// buffer which contains the local density of the R, G and B photoreceptors for a normalization use
+	std::valarray<double> _imageGradient;
+
+	// variables
+	double _pR, _pG, _pB; // probabilities of color R, G and B
+	bool _objectInit;
+
+	// protected functions
+	void _initColorSampling();
+	void _interpolateImageDemultiplexedImage(double *inputOutputBuffer);
+	void _interpolateSingleChannelImage111(double *inputOutputBuffer);
+	void _interpolateBayerRGBchannels(double *inputOutputBuffer);
+	void _applyRIFfilter(const double *sourceBuffer, double *destinationBuffer);
+	void _getNormalizedContoursImage(const double *inputFrame, double *outputFrame);
+	// -> special adaptive filters dedicated to low pass filtering on the chrominance (skeeps filtering on the edges)
+	void _adaptiveSpatialLPfilter(const double *inputFrame,  double *outputFrame);
+	void _adaptiveHorizontalCausalFilter_addInput(const double *inputFrame, double *outputFrame, const unsigned int IDrowStart, const unsigned int IDrowEnd);
+	void _adaptiveHorizontalAnticausalFilter(double *outputFrame, const unsigned int IDrowStart, const unsigned int IDrowEnd);
+	void _adaptiveVerticalCausalFilter(double *outputFrame, const unsigned int IDcolumnStart, const unsigned int IDcolumnEnd);
+	void _adaptiveVerticalAnticausalFilter_multGain(double *outputFrame, const unsigned int IDcolumnStart, const unsigned int IDcolumnEnd);
+	void _computeGradient(const double *luminance);
+	void _normalizeOutputs_0_maxOutputValue(void);
+
+	// color space transform
+	void _applyImageColorSpaceConversion(const std::valarray<double> &inputFrame, std::valarray<double> &outputFrame, const double *transformTable);
+
+};
+}
+
+#endif /*RETINACOLOR_HPP_*/
+
+
diff --git a/modules/contrib/src/retinafilter.cpp b/modules/contrib/src/retinafilter.cpp
new file mode 100644
index 0000000000..672963554d
--- /dev/null
+++ b/modules/contrib/src/retinafilter.cpp
@@ -0,0 +1,531 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+#include "precomp.hpp"
+
+#include "retinafilter.hpp"
+
+// @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC : www.listic.univ-savoie.fr, Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+
+#include <iostream>
+#include <cmath>
+
+namespace cv
+{
+// standard constructor without any log sampling of the input frame
+RetinaFilter::RetinaFilter(const unsigned int sizeRows, const unsigned int sizeColumns, const bool colorMode, const RETINA_COLORSAMPLINGMETHOD samplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
+:
+		   _retinaParvoMagnoMappedFrame(0),
+		   _retinaParvoMagnoMapCoefTable(0),
+		   _photoreceptorsPrefilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), 4),
+		   _ParvoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)),
+		   _MagnoRetinaFilter((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor)),
+		   _colorEngine((1-(int)useRetinaLogSampling)*sizeRows+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeRows, reductionFactor), (1-(int)useRetinaLogSampling)*sizeColumns+useRetinaLogSampling*ImageLogPolProjection::predictOutputSize(sizeColumns, reductionFactor), samplingMethod),
+		   // configure retina photoreceptors log sampling... if necessary
+		   _photoreceptorsLogSampling(NULL)
+{
+
+#ifdef RETINADEBUG
+	std::cout<<"RetinaFilter::size( "<<_photoreceptorsPrefilter.getNBrows()<<", "<<_photoreceptorsPrefilter.getNBcolumns()<<")"<<" =? "<<_photoreceptorsPrefilter.getNBpixels()<<std::endl;
+#endif
+	if (useRetinaLogSampling)
+	{
+		_photoreceptorsLogSampling = new ImageLogPolProjection(sizeRows, sizeColumns, ImageLogPolProjection::RETINALOGPROJECTION, true);
+		if (!_photoreceptorsLogSampling->initProjection(reductionFactor, samplingStrenght))
+		{
+			std::cerr<<"RetinaFilter::Problem initializing photoreceptors log sampling, could not setup retina filter"<<std::endl;
+			delete _photoreceptorsLogSampling;
+			_photoreceptorsLogSampling=NULL;
+		}
+		else
+		{
+#ifdef RETINADEBUG
+			std::cout<<"_photoreceptorsLogSampling::size( "<<_photoreceptorsLogSampling->getNBrows()<<", "<<_photoreceptorsLogSampling->getNBcolumns()<<")"<<" =? "<<_photoreceptorsLogSampling->getNBpixels()<<std::endl;
+#endif
+		}
+	}
+
+	// set default processing activities
+	_useParvoOutput=true;
+	_useMagnoOutput=true;
+
+	_useColorMode=colorMode;
+
+	// create hybrid output and related coefficient table
+	_createHybridTable();
+
+	// set default parameters
+	setGlobalParameters();
+
+	// stability controls values init
+	_setInitPeriodCount();
+	_globalTemporalConstant=25;
+
+	// reset all buffers
+	clearAllBuffers();
+
+
+	//	std::cout<<"RetinaFilter::size( "<<this->getNBrows()<<", "<<this->getNBcolumns()<<")"<<_filterOutput.size()<<" =? "<<_filterOutput.getNBpixels()<<std::endl;
+
+}
+
+// destructor
+RetinaFilter::~RetinaFilter()
+{
+	if (_photoreceptorsLogSampling!=NULL)
+		delete _photoreceptorsLogSampling;
+}
+
+// function that clears all buffers of the object
+void RetinaFilter::clearAllBuffers()
+{
+	_photoreceptorsPrefilter.clearAllBuffers();
+	_ParvoRetinaFilter.clearAllBuffers();
+	_MagnoRetinaFilter.clearAllBuffers();
+	_colorEngine.clearAllBuffers();
+	if (_photoreceptorsLogSampling!=NULL)
+		_photoreceptorsLogSampling->clearAllBuffers();
+	// stability controls value init
+	_setInitPeriodCount();
+}
+
+/**
+* resize retina filter object (resize all allocated buffers
+* @param NBrows: the new height size
+* @param NBcolumns: the new width size
+*/
+void RetinaFilter::resize(const unsigned int NBrows, const unsigned int NBcolumns)
+{
+	unsigned int rows=NBrows, cols=NBcolumns;
+
+	// resize optionnal member and adjust other modules size if required
+	if (_photoreceptorsLogSampling)
+	{
+		_photoreceptorsLogSampling->resize(NBrows, NBcolumns);
+		rows=_photoreceptorsLogSampling->getOutputNBrows();
+		cols=_photoreceptorsLogSampling->getOutputNBcolumns();
+	}
+
+	_photoreceptorsPrefilter.resize(rows, cols);
+	_ParvoRetinaFilter.resize(rows, cols);
+	_MagnoRetinaFilter.resize(rows, cols);
+	_colorEngine.resize(rows, cols);
+
+	// reset parvo magno mapping
+	_createHybridTable();
+
+	// clean buffers
+	clearAllBuffers();
+
+}
+
+// stability controls value init
+void RetinaFilter::_setInitPeriodCount()
+{
+
+	// find out the maximum temporal constant value and apply a security factor
+	// false value (obviously too long) but appropriate for simple use
+	_globalTemporalConstant=(unsigned int)(_ParvoRetinaFilter.getPhotoreceptorsTemporalConstant()+_ParvoRetinaFilter.getHcellsTemporalConstant()+_MagnoRetinaFilter.getTemporalConstant());
+	// reset frame counter
+	_ellapsedFramesSinceLastReset=0;
+}
+
+void RetinaFilter::_createHybridTable()
+{
+	// create hybrid output and related coefficient table
+	_retinaParvoMagnoMappedFrame.resize(_photoreceptorsPrefilter.getNBpixels());
+
+	_retinaParvoMagnoMapCoefTable.resize(_photoreceptorsPrefilter.getNBpixels()*2);
+
+	// fill _hybridParvoMagnoCoefTable
+	int i, j, halfRows=_photoreceptorsPrefilter.getNBrows()/2, halfColumns=_photoreceptorsPrefilter.getNBcolumns()/2;
+	double *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
+	double minDistance=MIN(halfRows, halfColumns)*0.7;
+	for (i=0;i<(int)_photoreceptorsPrefilter.getNBrows();++i)
+	{
+		for (j=0;j<(int)_photoreceptorsPrefilter.getNBcolumns();++j)
+		{
+			double distanceToCenter=sqrt(((double)(i-halfRows)*(i-halfRows)+(j-halfColumns)*(j-halfColumns)));
+			if (distanceToCenter<minDistance)
+			{
+				double a=*(hybridParvoMagnoCoefTablePTR++)=0.5+0.5*cos(CV_PI*distanceToCenter/minDistance);
+				*(hybridParvoMagnoCoefTablePTR++)=1.0-a;
+			}else
+			{
+				*(hybridParvoMagnoCoefTablePTR++)=0;
+				*(hybridParvoMagnoCoefTablePTR++)=1.0;
+			}
+		}
+	}
+}
+
+// setup parameters function and global data filling
+void RetinaFilter::setGlobalParameters(const double OPLspatialResponse1, const double OPLtemporalresponse1, const double OPLassymetryGain, const double OPLspatialResponse2, const double OPLtemporalresponse2, const double LPfilterSpatialResponse, const double LPfilterGain, const double LPfilterTemporalresponse, const double MovingContoursExtractorCoefficient, const bool normalizeParvoOutput_0_maxOutputValue, const bool normalizeMagnoOutput_0_maxOutputValue, const double maxOutputValue, const double maxInputValue, const double meanValue)
+{
+	_normalizeParvoOutput_0_maxOutputValue=normalizeParvoOutput_0_maxOutputValue;
+	_normalizeMagnoOutput_0_maxOutputValue=normalizeMagnoOutput_0_maxOutputValue;
+	_maxOutputValue=maxOutputValue;
+	_photoreceptorsPrefilter.setV0CompressionParameter(0.9, maxInputValue, meanValue);
+	_photoreceptorsPrefilter.setLPfilterParameters(10, 0, 1.5, 1); // keeps low pass filter with high cut frequency in memory (usefull for the tone mapping function)
+	_photoreceptorsPrefilter.setLPfilterParameters(10, 0, 3.0, 2); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function)
+	_photoreceptorsPrefilter.setLPfilterParameters(0, 0, 10, 3); // keeps low pass filter with low cut frequency in memory (usefull for the tone mapping function)
+	//this->setV0CompressionParameter(0.6, maxInputValue, meanValue); // keeps log compression sensitivity parameter (usefull for the tone mapping function)
+	_ParvoRetinaFilter.setOPLandParvoFiltersParameters(0,OPLtemporalresponse1, OPLspatialResponse1, OPLassymetryGain, OPLtemporalresponse2, OPLspatialResponse2);
+	_ParvoRetinaFilter.setV0CompressionParameter(0.9, maxInputValue, meanValue);
+	_MagnoRetinaFilter.setCoefficientsTable(LPfilterGain, LPfilterTemporalresponse, LPfilterSpatialResponse, MovingContoursExtractorCoefficient, 0, 2.0*LPfilterSpatialResponse);
+	_MagnoRetinaFilter.setV0CompressionParameter(0.7, maxInputValue, meanValue);
+
+	// stability controls value init
+	_setInitPeriodCount();
+}
+
+const bool RetinaFilter::checkInput(const std::valarray<double> &input, const bool)
+{
+
+	BasicRetinaFilter *inputTarget=&_photoreceptorsPrefilter;
+	if (_photoreceptorsLogSampling)
+		inputTarget=_photoreceptorsLogSampling;
+
+	bool test=input.size()==inputTarget->getNBpixels() || input.size()==(inputTarget->getNBpixels()*3) ;
+	if (!test)
+	{
+		std::cerr<<"RetinaFilter::checkInput: input buffer does not match retina buffer size, conversion aborted"<<std::endl;
+		std::cout<<"RetinaFilter::checkInput: input size="<<input.size()<<" / "<<"retina size="<<inputTarget->getNBpixels()<<std::endl;
+		return false;
+	}
+
+	return true;
+}
+
+// main function that runs the filter for a given input frame
+const bool RetinaFilter::runFilter(const std::valarray<double> &imageInput, const bool useAdaptiveFiltering, const bool processRetinaParvoMagnoMapping, const bool useColorMode, const bool inputIsColorMultiplexed)
+{
+	// preliminary check
+	bool processSuccess=true;
+	if (!checkInput(imageInput, useColorMode))
+		return false;
+
+	// run the color multiplexing if needed and compute each suub filter of the retina:
+	// -> local adaptation
+	// -> contours OPL extraction
+	// -> moving contours extraction
+
+	// stability controls value update
+	++_ellapsedFramesSinceLastReset;
+
+	_useColorMode=useColorMode;
+
+	/* pointer to the appropriate input data after,
+	 * by default, if graylevel mode, the input is processed,
+	 * if color or something else must be considered, specific preprocessing are applied
+	 */
+
+	const std::valarray<double> *selectedPhotoreceptorsLocalAdaptationInput= &imageInput;
+	const std::valarray<double> *selectedPhotoreceptorsColorInput=&imageInput;
+
+	//********** Following is input data specific photoreceptors processing
+	if (_photoreceptorsLogSampling)
+	{
+		_photoreceptorsLogSampling->runProjection(imageInput, useColorMode);
+		selectedPhotoreceptorsColorInput=selectedPhotoreceptorsLocalAdaptationInput=&(_photoreceptorsLogSampling->getSampledFrame());
+	}
+
+	if (useColorMode&& (!inputIsColorMultiplexed)) // not multiplexed color input case
+	{
+		_colorEngine.runColorMultiplexing(*selectedPhotoreceptorsColorInput);
+		selectedPhotoreceptorsLocalAdaptationInput=&(_colorEngine.getMultiplexedFrame());
+	}
+
+	//********** Following is generic Retina processing
+
+	// photoreceptors local adaptation
+	_photoreceptorsPrefilter.runFilter_LocalAdapdation(*selectedPhotoreceptorsLocalAdaptationInput, _ParvoRetinaFilter.getHorizontalCellsOutput());
+	// safety pixel values checks
+	//_photoreceptorsPrefilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
+
+	// run parvo filter
+	_ParvoRetinaFilter.runFilter(_photoreceptorsPrefilter.getOutput(), _useParvoOutput);
+
+	if (_useParvoOutput)
+	{
+		_ParvoRetinaFilter.normalizeGrayOutputCentredSigmoide(); // models the saturation of the cells, usefull for visualisation of the ON-OFF Parvo Output, Bipolar cells outputs do not change !!!
+		_ParvoRetinaFilter.centerReductImageLuminance(); // best for further spectrum analysis
+
+		if (_normalizeParvoOutput_0_maxOutputValue)
+			_ParvoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
+	}
+
+	if (_useParvoOutput&&_useMagnoOutput)
+	{
+		_MagnoRetinaFilter.runFilter(_ParvoRetinaFilter.getBipolarCellsON(), _ParvoRetinaFilter.getBipolarCellsOFF());
+		if (_normalizeMagnoOutput_0_maxOutputValue)
+		{
+			_MagnoRetinaFilter.normalizeGrayOutput_0_maxOutputValue(_maxOutputValue);
+		}
+		_MagnoRetinaFilter.normalizeGrayOutputNearZeroCentreredSigmoide();
+	}
+
+	if (_useParvoOutput&&_useMagnoOutput&&processRetinaParvoMagnoMapping)
+	{
+		_processRetinaParvoMagnoMapping();
+		if (_useColorMode)
+			_colorEngine.runColorDemultiplexing(_retinaParvoMagnoMappedFrame, useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
+
+		return processSuccess;
+	}
+
+	if (_useParvoOutput&&_useColorMode)
+	{
+		_colorEngine.runColorDemultiplexing(_ParvoRetinaFilter.getOutput(), useAdaptiveFiltering, _maxOutputValue);//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
+		// compute A Cr1 Cr2 to LMS color space conversion
+		//if (true)
+		//  _applyImageColorSpaceConversion(_ColorEngine->getChrominance(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2);
+	}
+
+	return processSuccess;
+}
+
+const std::valarray<double> &RetinaFilter::getContours()
+{
+	if (_useColorMode)
+		return _colorEngine.getLuminance();
+	else
+		return _ParvoRetinaFilter.getOutput();
+}
+
+// run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated
+void RetinaFilter::runGrayToneMapping(const std::valarray<double> &grayImageInput, std::valarray<double> &grayImageOutput, const double PhotoreceptorsCompression, const double ganglionCellsCompression)
+{
+	// preliminary check
+	if (!checkInput(grayImageInput, false))
+		return;
+
+	this->_runGrayToneMapping(grayImageInput, grayImageOutput, PhotoreceptorsCompression, ganglionCellsCompression);
+}
+
+// run the initilized retina filter in order to perform gray image tone mapping, after this call all retina outputs are updated
+void RetinaFilter::_runGrayToneMapping(const std::valarray<double> &grayImageInput, std::valarray<double> &grayImageOutput, const double PhotoreceptorsCompression, const double ganglionCellsCompression)
+{
+	// stability controls value update
+	++_ellapsedFramesSinceLastReset;
+
+	std::valarray<double> temp2(grayImageInput.size());
+
+	// apply tone mapping on the multiplexed image
+	// -> photoreceptors local adaptation (large area adaptation)
+	_photoreceptorsPrefilter.runFilter_LPfilter(grayImageInput, grayImageOutput, 2); // compute low pass filtering modeling the horizontal cells filtering to acess local luminance
+	_photoreceptorsPrefilter.setV0CompressionParameterToneMapping(PhotoreceptorsCompression, grayImageOutput.sum()/(double)_photoreceptorsPrefilter.getNBpixels());
+	_photoreceptorsPrefilter.runFilter_LocalAdapdation(grayImageInput, grayImageOutput, temp2); // adapt contrast to local luminance
+
+	// high pass filter
+	//_spatiotemporalLPfilter(_localBuffer, _filterOutput, 2); // compute low pass filtering (high cut frequency (remove spatio-temporal noise)
+
+	//for (unsigned int i=0;i<_NBpixels;++i)
+	//  _localBuffer[i]-= _filterOutput[i]/2.0;
+
+	// -> ganglion cells local adaptation (short area adaptation)
+	_photoreceptorsPrefilter.runFilter_LPfilter(temp2, grayImageOutput, 1); // compute low pass filtering (high cut frequency (remove spatio-temporal noise)
+	_photoreceptorsPrefilter.setV0CompressionParameterToneMapping(ganglionCellsCompression, temp2.max(), temp2.sum()/(double)_photoreceptorsPrefilter.getNBpixels());
+	_photoreceptorsPrefilter.runFilter_LocalAdapdation(temp2, grayImageOutput, grayImageOutput); // adapt contrast to local luminance
+
+}
+// run the initilized retina filter in order to perform color tone mapping, after this call all retina outputs are updated
+void RetinaFilter::runRGBToneMapping(const std::valarray<double> &RGBimageInput, std::valarray<double> &RGBimageOutput, const bool useAdaptiveFiltering, const double PhotoreceptorsCompression, const double ganglionCellsCompression)
+{
+	// preliminary check
+	if (!checkInput(RGBimageInput, true))
+		return;
+
+	// multiplex the image with the color sampling method specified in the constructor
+	_colorEngine.runColorMultiplexing(RGBimageInput);
+
+	// apply tone mapping on the multiplexed image
+	_runGrayToneMapping(_colorEngine.getMultiplexedFrame(), RGBimageOutput, PhotoreceptorsCompression, ganglionCellsCompression);
+
+	// demultiplex tone maped image
+	_colorEngine.runColorDemultiplexing(RGBimageOutput, useAdaptiveFiltering, _photoreceptorsPrefilter.getMaxInputValue());//_ColorEngine->getMultiplexedFrame());//_ParvoRetinaFilter->getPhotoreceptorsLPfilteringOutput());
+
+	// rescaling result between 0 and 255
+	_colorEngine.normalizeRGBOutput_0_maxOutputValue(255.0);
+
+	// return the result
+	RGBimageOutput=_colorEngine.getDemultiplexedColorFrame();
+}
+
+void RetinaFilter::runLMSToneMapping(const std::valarray<double> &, std::valarray<double> &, const bool, const double, const double)
+{
+	std::cerr<<"not working, sorry"<<std::endl;
+
+	/*  // preliminary check
+    const std::valarray<double> &bufferInput=checkInput(LMSimageInput, true);
+    if (!bufferInput)
+      return NULL;
+
+    if (!_useColorMode)
+      std::cerr<<"RetinaFilter::Can not call tone mapping oeration if the retina filter was created for gray scale images"<<std::endl;
+
+    // create a temporary buffer of size nrows, Mcolumns, 3 layers
+    std::valarray<double> lmsTempBuffer(LMSimageInput);
+    std::cout<<"RetinaFilter::--->min LMS value="<<lmsTempBuffer.min()<<std::endl;
+
+    // setup local adaptation parameter at the photoreceptors level
+    setV0CompressionParameter(PhotoreceptorsCompression, _maxInputValue);
+    // get the local energy of each color channel
+    // ->L
+    _spatiotemporalLPfilter(LMSimageInput, _filterOutput, 1);
+    setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
+    _localLuminanceAdaptation(LMSimageInput, _filterOutput, lmsTempBuffer.Buffer());
+    // ->M
+    _spatiotemporalLPfilter(LMSimageInput+_NBpixels, _filterOutput, 1);
+    setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
+    _localLuminanceAdaptation(LMSimageInput+_NBpixels, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels);
+    // ->S
+    _spatiotemporalLPfilter(LMSimageInput+_NBpixels*2, _filterOutput, 1);
+    setV0CompressionParameterToneMapping(PhotoreceptorsCompression, _maxInputValue, this->sum()/_NBpixels);
+    _localLuminanceAdaptation(LMSimageInput+_NBpixels*2, _filterOutput, lmsTempBuffer.Buffer()+_NBpixels*2);
+
+    // eliminate negative values
+    for (unsigned int i=0;i<lmsTempBuffer.size();++i)
+      if (lmsTempBuffer.Buffer()[i]<0)
+        lmsTempBuffer.Buffer()[i]=0;
+    std::cout<<"RetinaFilter::->min LMS value="<<lmsTempBuffer.min()<<std::endl;
+
+    // compute LMS to A Cr1 Cr2 color space conversion
+    _applyImageColorSpaceConversion(lmsTempBuffer.Buffer(), lmsTempBuffer.Buffer(), _LMStoACr1Cr2);
+
+    TemplateBuffer <double> acr1cr2TempBuffer(_NBrows, _NBcolumns, 3);
+    memcpy(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), sizeof(double)*_NBpixels*3);
+
+    // compute A Cr1 Cr2 to LMS color space conversion
+    _applyImageColorSpaceConversion(acr1cr2TempBuffer.Buffer(), lmsTempBuffer.Buffer(), _ACr1Cr2toLMS);
+
+    // eliminate negative values
+    for (unsigned int i=0;i<lmsTempBuffer.size();++i)
+      if (lmsTempBuffer.Buffer()[i]<0)
+        lmsTempBuffer.Buffer()[i]=0;
+
+    // rewrite output to the appropriate buffer
+    _colorEngine->setDemultiplexedColorFrame(lmsTempBuffer.Buffer());
+	 */
+}
+
+// return image with center Parvo and peripheral Magno channels
+void RetinaFilter::_processRetinaParvoMagnoMapping()
+{
+	register double *hybridParvoMagnoPTR= &_retinaParvoMagnoMappedFrame[0];
+	register const double *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
+	register const double *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
+	register double *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
+
+	for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
+	{
+		double hybridValue=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR)+*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR+1);
+		*(hybridParvoMagnoPTR++)=hybridValue;
+	}
+
+	TemplateBuffer<double>::normalizeGrayOutput_0_maxOutputValue(&_retinaParvoMagnoMappedFrame[0], _photoreceptorsPrefilter.getNBpixels());
+
+}
+
+const bool RetinaFilter::getParvoFoveaResponse(std::valarray<double> &parvoFovealResponse)
+{
+	if (!_useParvoOutput)
+		return false;
+	if (parvoFovealResponse.size() != _ParvoRetinaFilter.getNBpixels())
+		return false;
+
+	register const double *parvoOutputPTR= get_data(_ParvoRetinaFilter.getOutput());
+	register double *fovealParvoResponsePTR= &parvoFovealResponse[0];
+	register double *hybridParvoMagnoCoefTablePTR= &_retinaParvoMagnoMapCoefTable[0];
+
+	for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
+	{
+		*(fovealParvoResponsePTR++)=*(parvoOutputPTR++)**(hybridParvoMagnoCoefTablePTR);
+	}
+
+	return true;
+}
+
+// method to retrieve the parafoveal magnocellular pathway response (no energy motion in fovea)
+const bool RetinaFilter::getMagnoParaFoveaResponse(std::valarray<double> &magnoParafovealResponse)
+{
+	if (!_useMagnoOutput)
+		return false;
+	if (magnoParafovealResponse.size() != _MagnoRetinaFilter.getNBpixels())
+		return false;
+
+	register const double *magnoXOutputPTR= get_data(_MagnoRetinaFilter.getOutput());
+	register double *parafovealMagnoResponsePTR=&magnoParafovealResponse[0];
+	register double *hybridParvoMagnoCoefTablePTR=&_retinaParvoMagnoMapCoefTable[0]+1;
+
+	for (unsigned int i=0 ; i<_photoreceptorsPrefilter.getNBpixels() ; ++i, hybridParvoMagnoCoefTablePTR+=2)
+	{
+		*(parafovealMagnoResponsePTR++)=*(magnoXOutputPTR++)**(hybridParvoMagnoCoefTablePTR);
+	}
+
+	return true;
+}
+
+
+}
diff --git a/modules/contrib/src/retinafilter.hpp b/modules/contrib/src/retinafilter.hpp
new file mode 100644
index 0000000000..d378870d90
--- /dev/null
+++ b/modules/contrib/src/retinafilter.hpp
@@ -0,0 +1,540 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * 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.
+*******************************************************************************/
+
+/**
+* @class  RetinaFilter
+* @brief class which describes the retina model developped at the LIS/GIPSA-LAB www.gipsa-lab.inpg.fr:
+* -> performs a contours and moving contours extraction with powerfull local data enhancement as at the retina level
+* Based on Alexandre BENOIT thesis: "Le systeme visuel humain au secours de la vision par ordinateur"
+*
+* => various optimisations and enhancements added after 2007 such as tone mapping capabilities, see reference paper cited in the licence and :
+* Benoit A.,Alleysson D., Herault J., Le Callet P. (2009),  "Spatio-Temporal Tone Mapping Operator based on a Retina model", Computational Color Imaging Workshop (CCIW09),pp 12-22, Saint Etienne, France
+*
+* TYPICAL USE:
+*
+* // create object at a specified picture size
+* Retina *retina;
+* retina =new Retina(frameSizeRows, frameSizeColumns, RGBmode);
+*
+* // init gain, spatial and temporal parameters:
+* retina->setParameters(0.7, 1, 0, 7, 1, 5, 0, 0, 3 , true);
+*
+* // during program execution, call the filter for local luminance correction,  contours extraction, moving contours extraction from an input picture called "FrameBuffer":
+* retina->runfilter(FrameBuffer);
+*
+* // get the different output frames, check in the class description below for more outputs:
+* const std::valarray<double> correctedLuminance=retina->getLocalAdaptation();
+* const std::valarray<double> contours=retina->getContours();
+* const std::valarray<double> movingContours=retina->getMovingContours();
+*
+* // at the end of the program, destroy object:
+* delete retina;
+*
+* @author Alexandre BENOIT, benoit.alexandre.vision@gmail.com, LISTIC / Gipsa-Lab, France: www.gipsa-lab.inpg.fr/
+* Creation date 2007
+*/
+
+#ifndef RETINACLASSES_H_
+#define RETINACLASSES_H_
+
+#include "basicretinafilter.hpp"
+#include "parvoretinafilter.hpp"
+#include "magnoretinafilter.hpp"
+
+// optional includes (depending on the related publications)
+#include "imagelogpolprojection.hpp"
+
+#include "retinacolor.hpp"
+
+//#define __RETINADEBUG // define RETINADEBUG to display debug data
+namespace cv
+{
+
+// retina class that process the 3 outputs of the retina filtering stages
+class RetinaFilter//: public BasicRetinaFilter
+{
+public:
+
+	/**
+	* constructor of the retina filter model with log sampling of the input frame (models the photoreceptors log sampling (central high resolution fovea and lower precision borders))
+	* @param sizeRows: number of rows of the input image
+	* @param sizeColumns: number of columns of the input image
+	* @param colorMode: specifies if the retina works with color (true) of stays in grayscale processing (false), can be adjusted online by the use of setColorMode method
+	* @param samplingMethod: specifies which kind of color sampling will be used
+	* @param useRetinaLogSampling: activate retina log sampling, if true, the 2 following parameters can be used
+	* @param reductionFactor: only usefull if param useRetinaLogSampling=true, specifies the reduction factor of the output frame (as the center (fovea) is high resolution and corners can be underscaled, then a reduction of the output is allowed without precision leak
+	* @param samplingStrenght: only usefull if param useRetinaLogSampling=true, specifies the strenght of the log scale that is applied
+	*/
+	RetinaFilter(const unsigned int sizeRows, const unsigned int sizeColumns, const bool colorMode=false, const RETINA_COLORSAMPLINGMETHOD samplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);
+
+	/**
+	* standard destructor
+	*/
+	~RetinaFilter();
+
+	/**
+	* function that clears all buffers of the object
+	*/
+	void clearAllBuffers();
+
+	/**
+	* resize retina parvo filter object (resize all allocated buffers)
+	* @param NBrows: the new height size
+	* @param NBcolumns: the new width size
+	*/
+	void resize(const unsigned int NBrows, const unsigned int NBcolumns);
+
+	/**
+	* Input buffer checker: allows to check if the passed image buffer corresponds to retina filter expectations
+	* @param input: the input image buffer
+	* @param colorMode: specifiy if the input should be considered by the retina as colored of not
+	* @return false if not compatible or it returns true if OK
+	*/
+	const bool checkInput(const std::valarray<double> &input, const bool colorMode);
+
+	/**
+	* run the initilized retina filter, after this call all retina outputs are updated
+	* @param imageInput: image input buffer, can be grayscale or RGB image respecting the size specified at the constructor level
+	* @param useAdaptiveFiltering: set true if you want to use adaptive color demultilexing (solve some color artefact problems), see RetinaColor for citation references
+	* @param processRetinaParvoMagnoMapping: tels if the main outputs takes into account the mapping of the Parvo and Magno channels on the retina (centred parvo (fovea) and magno outside (parafovea))
+	* @param useColorMode: color information is used if true, warning, if input is only gray level, a buffer overflow error will occur
+	-> note that if color mode is activated and processRetinaParvoMagnoMapping==true, then the demultiplexed color frame (accessible throw getColorOutput() will be a color contours frame in the fovea and gray level moving contours outside
+	@param inputIsColorMultiplexed: set trus if the input data is a multiplexed color image (using Bayer sampling for example), the color sampling method must correspond to the RETINA_COLORSAMPLINGMETHOD passed at constructor!
+	* @return true if process ran well, false in case of failure
+	*/
+	const bool runFilter(const std::valarray<double> &imageInput, const bool useAdaptiveFiltering=true, const bool processRetinaParvoMagnoMapping=false, const bool useColorMode=false, const bool inputIsColorMultiplexed=false);
+
+	/**
+	* run the initilized retina filter in order to perform color tone mapping applied on an RGB image, after this call the color output of the retina is updated (use function getColorOutput() to grab it)
+	* the algorithm is based on David Alleyson, Sabine Susstruck and Laurence Meylan's work, please cite:
+	* -> Meylan L., Alleysson D., and S�sstrunk S., A Model of Retinal Local Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of America, A, Vol. 24, N� 9, September, 1st, 2007, pp. 2807-2816
+	* get the resulting gray frame by calling function getParvoColor()
+	* @param grayImageInput: RGB image input buffer respecting the size specified at the constructor level
+	* @param PhotoreceptorsCompression: sets the log compression parameters applied at the photoreceptors level (enhance luminance in dark areas)
+	* @param ganglionCellsCompression: sets the log compression applied at the gnaglion cells output (enhance contrast)
+	*/
+	void runGrayToneMapping(const std::valarray<double> &grayImageInput, std::valarray<double> &grayImageOutput, const double PhotoreceptorsCompression=0.6, const double ganglionCellsCompression=0.6);
+
+	/**
+	* run the initilized retina filter in order to perform color tone mapping applied on an RGB image, after this call the color output of the retina is updated (use function getColorOutput() to grab it)
+	* the algorithm is based on David Alleyson, Sabine Susstruck and Laurence Meylan's work, please cite:
+	* -> Meylan L., Alleysson D., and S�sstrunk S., A Model of Retinal Local Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of America, A, Vol. 24, N� 9, September, 1st, 2007, pp. 2807-2816
+	* get the resulting RGB frame by calling function getParvoColor()
+	* @param RGBimageInput: RGB image input buffer respecting the size specified at the constructor level
+	* @param useAdaptiveFiltering: set true if you want to use adaptive color demultilexing (solve some color artefact problems), see RetinaColor for citation references
+	* @param PhotoreceptorsCompression: sets the log compression parameters applied at the photoreceptors level (enhance luminance in dark areas)
+	* @param ganglionCellsCompression: sets the log compression applied at the ganglion cells output (enhance contrast)
+	*/
+	void runRGBToneMapping(const std::valarray<double> &RGBimageInput, std::valarray<double> &imageOutput, const bool useAdaptiveFiltering, const double PhotoreceptorsCompression=0.6, const double ganglionCellsCompression=0.6);
+
+	/**
+	* run the initilized retina filter in order to perform color tone mapping applied on an RGB image, after this call the color output of the retina is updated (use function getColorOutput() to grab it)
+	* get the resulting RGB frame by calling function getParvoColor()
+	* @param LMSimageInput: RGB image input buffer respecting the size specified at the constructor level
+	* @param useAdaptiveFiltering: set true if you want to use adaptive color demultilexing (solve some color artefact problems), see RetinaColor for citation references
+	* @param PhotoreceptorsCompression: sets the log compression parameters applied at the photoreceptors level (enhance luminance in dark areas)
+	* @param ganglionCellsCompression: sets the log compression applied at the gnaglion cells output (enhance contrast)
+	*/
+	void runLMSToneMapping(const std::valarray<double> &LMSimageInput, std::valarray<double> &imageOutput, const bool useAdaptiveFiltering, const double PhotoreceptorsCompression=0.6, const double ganglionCellsCompression=0.6);
+
+	/**
+	* set up function of the retina filter: all the retina is initialized at this step, some specific parameters are set by default, use setOPLandParvoCoefficientsTable() and setMagnoCoefficientsTable in order to setup the retina with more options
+	* @param OPLspatialResponse1: (equal to k1 in setOPLandParvoCoefficientsTable() function) the spatial constant of the first order low pass filter of the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is pixels, typical value is 1 pixel
+	* @param OPLtemporalresponse1: (equal to tau1 in setOPLandParvoCoefficientsTable() function) the time constant of the first order low pass filter of the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is frames, typical value is 1 frame
+	* @param OPLassymetryGain: (equal to beta2 in setOPLandParvoCoefficientsTable() function) gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, then, the luminance is not filtered and is still reachable at the output, typicall value is 0
+	* @param OPLspatialResponse2: (equal to k2 in setOPLandParvoCoefficientsTable() function) the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel
+	* @param OPLtemporalresponse2: (equal to tau2 in setOPLandParvoCoefficientsTable() function) the time constant of the first order low pass filter of the horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is frames, typical value is 1 frame, as the photoreceptors
+	* @param LPfilterSpatialResponse: (equal to parasolCells_k in setMagnoCoefficientsTable() function) the low pass filter spatial constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical value is 5
+	* @param LPfilterGain: (equal to parasolCells_beta in setMagnoCoefficientsTable() function) the low pass filter gain used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), typical value is 0
+	* @param LPfilterTemporalresponse: (equal to parasolCells_tau in setMagnoCoefficientsTable() function) the low pass filter time constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical value is 0 (immediate response)
+	* @param MovingContoursExtractorCoefficient: (equal to amacrinCellsTemporalCutFrequency in setMagnoCoefficientsTable() function)the time constant of the first order high pass fiter of the magnocellular way (motion information channel), unit is frames, tipicall value is 5
+	* @param normalizeParvoOutput_0_maxOutputValue: specifies if the Parvo cellular output should be normalized between 0 and maxOutputValue (true) or not (false) in order to remain at a null mean value, true value is recommended for visualisation
+	* @param normalizeMagnoOutput_0_maxOutputValue: specifies if the Magno cellular output should be normalized between 0 and maxOutputValue (true) or not (false), setting true may be hazardous because it can enhace the noise response when nothing is moving
+	* @param maxOutputValue: the maximum amplitude value of the normalized outputs (generally 255 for 8bit per channel pictures)
+	* @param maxInputValue: the maximum pixel value of the input picture (generally 255 for 8bit per channel pictures), specify it in other case (for example High Dynamic Range Images)
+	* @param meanValue: the global mean value of the input data usefull for local adaptation setup
+	*/
+	void setGlobalParameters(const double OPLspatialResponse1=0.7, const double OPLtemporalresponse1=1, const double OPLassymetryGain=0, const double OPLspatialResponse2=5, const double OPLtemporalresponse2=1, const double LPfilterSpatialResponse=5, const double LPfilterGain=0, const double LPfilterTemporalresponse=0, const double MovingContoursExtractorCoefficient=5, const bool normalizeParvoOutput_0_maxOutputValue=false, const bool normalizeMagnoOutput_0_maxOutputValue=false, const double maxOutputValue=255.0, const double maxInputValue=255.0, const double meanValue=128.0);
+
+	/**
+	* setup the local luminance adaptation capability
+	* @param V0CompressionParameter: the compression strengh of the photoreceptors local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 160
+	*/
+	inline void setPhotoreceptorsLocalAdaptationSensitivity(const double V0CompressionParameter){_photoreceptorsPrefilter.setV0CompressionParameter(V0CompressionParameter);_setInitPeriodCount();};
+
+	/**
+	* setup the local luminance adaptation capability
+	* @param V0CompressionParameter: the compression strengh of the parvocellular pathway (details) local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 160
+	*/
+	inline void setParvoGanglionCellsLocalAdaptationSensitivity(const double V0CompressionParameter){_ParvoRetinaFilter.setV0CompressionParameter(V0CompressionParameter);_setInitPeriodCount();};
+
+	/**
+	* setup the local luminance adaptation area of integration
+	* @param spatialResponse: the spatial constant of the low pass filter applied on the bipolar cells output in order to compute local contrast mean values
+	* @param temporalResponse: the spatial constant of the low pass filter applied on the bipolar cells output in order to compute local contrast mean values (generally set to zero: immediate response)
+	*/
+	inline void setGanglionCellsLocalAdaptationLPfilterParameters(const double spatialResponse, const double temporalResponse){_ParvoRetinaFilter.setGanglionCellsLocalAdaptationLPfilterParameters(temporalResponse, spatialResponse);_setInitPeriodCount();};
+
+	/**
+	* setup the local luminance adaptation capability
+	* @param V0CompressionParameter: the compression strengh of the magnocellular pathway (motion) local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 160
+	*/
+	inline void setMagnoGanglionCellsLocalAdaptationSensitivity(const double V0CompressionParameter){_MagnoRetinaFilter.setV0CompressionParameter(V0CompressionParameter);_setInitPeriodCount();};
+
+	/**
+	* setup the OPL and IPL parvo channels
+	* @param beta1: gain of the horizontal cells network, if 0, then the mean value of the output is zero (default value), if the parameter is near 1, the amplitude is boosted but it should only be used for values rescaling... if needed
+	* @param tau1: the time constant of the first order low pass filter of the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is frames, typical value is 1 frame
+	* @param k1: the spatial constant of the first order low pass filter of the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is pixels, typical value is 1 pixel
+	* @param beta2: gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, then, the luminance is not filtered and is still reachable at the output, typicall value is 0
+	* @param tau2: the time constant of the first order low pass filter of the horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is frames, typical value is 1 frame, as the photoreceptors
+	* @param k2: the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel, this value is also used for local contrast computing when computing the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular channel model)
+	* @param V0CompressionParameter: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 230
+	*/
+	void setOPLandParvoParameters(const double beta1, const double tau1, const double k1, const double beta2, const double tau2, const double k2, const double V0CompressionParameter){_ParvoRetinaFilter.setOPLandParvoFiltersParameters(beta1, tau1, k1, beta2, tau2, k2);_ParvoRetinaFilter.setV0CompressionParameter(V0CompressionParameter);_setInitPeriodCount();};
+
+	/**
+	* set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel
+	* @param parasolCells_beta: the low pass filter gain used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), typical value is 0
+	* @param parasolCells_tau: the low pass filter time constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical value is 0 (immediate response)
+	* @param parasolCells_k: the low pass filter spatial constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical value is 5
+	* @param amacrinCellsTemporalCutFrequency: the time constant of the first order high pass fiter of the magnocellular way (motion information channel), unit is frames, tipicall value is 5
+	* @param V0CompressionParameter: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 200
+	* @param localAdaptintegration_tau: specifies the temporal constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+	* @param localAdaptintegration_k: specifies the spatial constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation
+	*/
+	void setMagnoCoefficientsTable(const double parasolCells_beta, const double parasolCells_tau, const double parasolCells_k, const double amacrinCellsTemporalCutFrequency, const double V0CompressionParameter, const double localAdaptintegration_tau, const double localAdaptintegration_k){_MagnoRetinaFilter.setCoefficientsTable(parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, localAdaptintegration_tau, localAdaptintegration_k);_MagnoRetinaFilter.setV0CompressionParameter(V0CompressionParameter);_setInitPeriodCount();};
+
+	/**
+	* set if the parvo output should be or not normalized between 0 and 255 (for display purpose generally)
+	* @param normalizeParvoOutput_0_maxOutputValue: true if normalization should be done
+	*/
+	inline void activateNormalizeParvoOutput_0_maxOutputValue(const bool normalizeParvoOutput_0_maxOutputValue){_normalizeParvoOutput_0_maxOutputValue=normalizeParvoOutput_0_maxOutputValue;};
+
+	/**
+	* set if the magno output should be or not normalized between 0 and 255 (for display purpose generally), take care, if nothing is moving, then, the noise will be enanced !!!
+	* @param normalizeMagnoOutput_0_maxOutputValue: true if normalization should be done
+	*/
+	inline void activateNormalizeMagnoOutput_0_maxOutputValue(const bool normalizeMagnoOutput_0_maxOutputValue){_normalizeMagnoOutput_0_maxOutputValue=normalizeMagnoOutput_0_maxOutputValue;};
+
+	/**
+	* setup the maximum amplitude value of the normalized outputs (generally 255 for 8bit per channel pictures)
+	* @param maxOutputValue: maximum amplitude value of the normalized outputs (generally 255 for 8bit per channel pictures)
+	*/
+	inline void setMaxOutputValue(const double maxOutputValue){_maxOutputValue=maxOutputValue;};
+
+	/**
+	* sets the color mode of the frame grabber
+	* @param desiredColorMode: true if the user needs color information, false for graylevels
+	*/
+	void setColorMode(const bool desiredColorMode){_useColorMode=desiredColorMode;};
+
+	/**
+	* activate color saturation as the final step of the color demultiplexing process
+	* -> this saturation is a sigmoide function applied to each channel of the demultiplexed image.
+	* @param saturateColors: boolean that activates color saturation (if true) or desactivate (if false)
+	* @param colorSaturationValue: the saturation factor
+	* */
+	inline void setColorSaturation(const bool saturateColors=true, const double colorSaturationValue=4.0){_colorEngine.setColorSaturation(saturateColors, colorSaturationValue);};
+
+	/////////////////////////////////////////////////////////////////
+	// function that retrieve the main retina outputs, one by one, or all in a structure
+
+	/**
+	* @return the input image sampled by the photoreceptors spatial sampling
+	*/
+	inline const std::valarray<double> &getPhotoreceptorsSampledFrame() const {if (_photoreceptorsLogSampling)return _photoreceptorsLogSampling->getSampledFrame();};
+
+	/**
+	* @return photoreceptors output, locally adapted luminance only, no high frequency spatio-temporal noise reduction at the next retina processing stages, use getPhotoreceptors method to get complete photoreceptors output
+	*/
+	inline const std::valarray<double> &getLocalAdaptation() const {return _photoreceptorsPrefilter.getOutput();};
+
+	/**
+	* @return photoreceptors output: locally adapted luminance and high frequency spatio-temporal noise reduction, high luminance is a little saturated at this stage, but this is corrected naturally at the next retina processing stages
+	*/
+	inline const std::valarray<double> &getPhotoreceptors() const {return _ParvoRetinaFilter.getPhotoreceptorsLPfilteringOutput();};
+
+	/**
+	* @return the local luminance of the processed frame (it is the horizontal cells output)
+	*/
+	inline const std::valarray<double> &getHorizontalCells() const {return _ParvoRetinaFilter.getHorizontalCellsOutput();};
+
+	///////// CONTOURS part, PARVOCELLULAR RETINA PATHWAY
+	/**
+	* @return true if Parvocellular output is activated, false if not
+	*/
+	inline const bool areContoursProcessed(){return _useParvoOutput;};
+
+	/**
+	*  method to retrieve the foveal parvocellular pathway response (no details energy in parafovea)
+	* @param parvoParafovealResponse: buffer that will be filled with the response of the magnocellular pathway in the parafoveal area
+	* @return true if process succeeded (if buffer exists, is its size matches retina size, if magno channel is activated and if mapping is initialized
+	*/
+	const bool getParvoFoveaResponse(std::valarray<double> &parvoFovealResponse);
+
+	/**
+	* @param useParvoOutput: true if Parvocellular output should be activated, false if not
+	*/
+	inline void activateContoursProcessing(const bool useParvoOutput){_useParvoOutput=useParvoOutput;};
+
+	/**
+	* @return the parvocellular contours information (details), should be used at the fovea level
+	*/
+	const std::valarray<double> &getContours(); // Parvocellular output
+
+	/**
+	* @return the parvocellular contours ON information (details), should be used at the fovea level
+	*/
+	inline const std::valarray<double> &getContoursON() const {return _ParvoRetinaFilter.getParvoON();};// Parvocellular ON output
+
+	/**
+	* @return the parvocellular contours OFF information (details), should be used at the fovea level
+	*/
+	inline const std::valarray<double> &getContoursOFF() const {return _ParvoRetinaFilter.getParvoOFF();};// Parvocellular OFF output
+
+	///////// MOVING CONTOURS part, MAGNOCELLULAR RETINA PATHWAY
+	/**
+	* @return true if Magnocellular output is activated, false if not
+	*/
+	inline const bool areMovingContoursProcessed(){return _useMagnoOutput;};
+
+	/**
+	*  method to retrieve the parafoveal magnocellular pathway response (no motion energy in fovea)
+	* @param magnoParafovealResponse: buffer that will be filled with the response of the magnocellular pathway in the parafoveal area
+	* @return true if process succeeded (if buffer exists, is its size matches retina size, if magno channel is activated and if mapping is initialized
+	*/
+	const bool getMagnoParaFoveaResponse(std::valarray<double> &magnoParafovealResponse);
+
+	/**
+	* @param useMagnoOutput: true if Magnoocellular output should be activated, false if not
+	*/
+	inline void activateMovingContoursProcessing(const bool useMagnoOutput){_useMagnoOutput=useMagnoOutput;};
+
+	/**
+	* @return the magnocellular moving contours information (motion), should be used at the parafovea level without post-processing
+	*/
+	inline const std::valarray<double> &getMovingContours() const {return _MagnoRetinaFilter.getOutput();};// Magnocellular output
+
+	/**
+	* @return the magnocellular moving contours information (motion), should be used at the parafovea level with assymetric sigmoide post-processing which saturates motion information
+	*/
+	inline const std::valarray<double> &getMovingContoursSaturated() const {return _MagnoRetinaFilter.getMagnoYsaturated();};// Saturated Magnocellular output
+
+	/**
+	* @return the magnocellular moving contours ON information (motion), should be used at the parafovea level without post-processing
+	*/
+	inline const std::valarray<double> &getMovingContoursON() const {return _MagnoRetinaFilter.getMagnoON();};// Magnocellular ON output
+
+	/**
+	* @return the magnocellular moving contours OFF information (motion), should be used at the parafovea level without post-processing
+	*/
+	inline const std::valarray<double> &getMovingContoursOFF() const {return _MagnoRetinaFilter.getMagnoOFF();};// Magnocellular OFF output
+
+	/**
+	* @return a gray level image with center Parvo and peripheral Magno X channels, WARNING, the result will be ok if you called previously fucntion runFilter(imageInput, processRetinaParvoMagnoMapping=true);
+	*    -> will be accessible even if color mode is activated (but the image is color sampled so quality is poor), but get the same thing but in color by the use of function getParvoColor()
+	*/
+	inline const std::valarray<double> &getRetinaParvoMagnoMappedOutput() const {return _retinaParvoMagnoMappedFrame;};// return image with center Parvo and peripheral Magno channels
+
+	/**
+	* color processing dedicated functions
+	* @return the parvo channel (contours, details) of the processed frame, grayscale output
+	*/
+	inline const std::valarray<double> &getParvoContoursChannel() const {return _colorEngine.getLuminance();};
+
+	/**
+	* color processing dedicated functions
+	* @return the chrominance of the processed frame (same colorspace as the input output, usually RGB)
+	*/
+	inline const std::valarray<double> &getParvoChrominance() const {return _colorEngine.getChrominance();}; // only retreive chrominance
+
+	/**
+	* color processing dedicated functions
+	* @return the parvo + chrominance channels of the processed frame (same colorspace as the input output, usually RGB)
+	*/
+	inline const std::valarray<double> &getColorOutput() const {return _colorEngine.getDemultiplexedColorFrame();};// retrieve luminance+chrominance
+
+	/**
+	* apply to the retina color output the Krauskopf transformation which leads to an opponent color system: output colorspace if Acr1cr2 if input of the retina was LMS color space
+	* @param result: the input buffer to fill with the transformed colorspace retina output
+	* @return true if process ended successfully
+	*/
+	inline const bool applyKrauskopfLMS2Acr1cr2Transform(std::valarray<double> &result){return _colorEngine.applyKrauskopfLMS2Acr1cr2Transform(result);};
+
+	/**
+	* apply to the retina color output the Krauskopf transformation which leads to an opponent color system: output colorspace if Acr1cr2 if input of the retina was LMS color space
+	* @param result: the input buffer to fill with the transformed colorspace retina output
+	* @return true if process ended successfully
+	*/
+	inline const bool applyLMS2LabTransform(std::valarray<double> &result){return _colorEngine.applyLMS2LabTransform(result);};
+
+	/**
+	* color processing dedicated functions
+	* @return the retina initialized mode, true if color mode (RGB), false if grayscale
+	*/
+	inline const bool isColorMode(){return _useColorMode;}; // return true if RGB mode, false if gray level mode
+
+	/**
+	* @return the irregular low pass filter ouput at the photoreceptors level
+	*/
+	inline const std::valarray<double> &getIrregularLPfilteredInputFrame() const {return _photoreceptorsLogSampling->getIrregularLPfilteredInputFrame();};
+
+	/**
+	* @return true if color mode is activated, false if gray levels processing
+	*/
+	const bool getColorMode(){return _useColorMode;};
+
+	/**
+	*
+	* @return true if a sufficient number of processed frames has been done since the last parameters update in order to get the stable state (r�gime permanent)
+	*/
+	inline const bool isInitTransitionDone(){if (_ellapsedFramesSinceLastReset<_globalTemporalConstant)return false; return true;};
+
+	/**
+	* find a distance in the image input space when the distance is known in the retina log sampled space...read again if it is not clear enough....sorry, i should sleep
+	* @param projectedRadiusLength: the distance to image center in the retina log sampled space
+	* @return the distance to image center in the input image space
+	*/
+	inline const double getRetinaSamplingBackProjection(const double projectedRadiusLength){if (_photoreceptorsLogSampling)return _photoreceptorsLogSampling->getOriginalRadiusLength(projectedRadiusLength);else return projectedRadiusLength;};
+
+	/////////////////:
+	// retina dimensions getters
+
+	/**
+	* @return number of rows of the filter
+	*/
+	inline const unsigned int getInputNBrows(){if (_photoreceptorsLogSampling) return _photoreceptorsLogSampling->getNBrows();else return _photoreceptorsPrefilter.getNBrows();};
+
+	/**
+	* @return number of columns of the filter
+	*/
+	inline const unsigned int getInputNBcolumns(){if (_photoreceptorsLogSampling) return _photoreceptorsLogSampling->getNBcolumns();else return _photoreceptorsPrefilter.getNBcolumns();};
+
+	/**
+	* @return number of pixels of the filter
+	*/
+	inline const unsigned int getInputNBpixels(){if (_photoreceptorsLogSampling) return _photoreceptorsLogSampling->getNBpixels();else return _photoreceptorsPrefilter.getNBpixels();};
+
+	/**
+	* @return the height of the frame output
+	*/
+	inline const unsigned int getOutputNBrows(){return _photoreceptorsPrefilter.getNBrows();};
+
+	/**
+	* @return the width of the frame output
+	*/
+	inline const unsigned int getOutputNBcolumns(){return _photoreceptorsPrefilter.getNBcolumns();};
+
+	/**
+	* @return the numbers of output pixels (width*height) of the images used by the object
+	*/
+	inline const unsigned int getOutputNBpixels(){return _photoreceptorsPrefilter.getNBpixels();};
+
+
+private:
+
+	// processing activation flags
+	bool _useParvoOutput;
+	bool _useMagnoOutput;
+
+
+	// filter stability controls
+	unsigned int _ellapsedFramesSinceLastReset;
+	unsigned int _globalTemporalConstant;
+
+	// private template buffers and related access pointers
+	std::valarray<double> _retinaParvoMagnoMappedFrame;
+	std::valarray<double> _retinaParvoMagnoMapCoefTable;
+	// private objects of the class
+	BasicRetinaFilter _photoreceptorsPrefilter;
+	ParvoRetinaFilter _ParvoRetinaFilter;
+	MagnoRetinaFilter _MagnoRetinaFilter;
+	RetinaColor       _colorEngine;
+	ImageLogPolProjection *_photoreceptorsLogSampling;
+
+	bool _useMinimalMemoryForToneMappingONLY;
+
+	bool _normalizeParvoOutput_0_maxOutputValue;
+	bool _normalizeMagnoOutput_0_maxOutputValue;
+	double _maxOutputValue;
+	bool _useColorMode;
+
+
+
+	// private functions
+	void _setInitPeriodCount();
+	void _createHybridTable();
+	void _processRetinaParvoMagnoMapping();
+	void _runGrayToneMapping(const std::valarray<double> &grayImageInput, std::valarray<double> &grayImageOutput ,const double PhotoreceptorsCompression=0.6, const double ganglionCellsCompression=0.6);
+
+
+};
+
+}
+#endif /*RETINACLASSES_H_*/
+
+
+
+
diff --git a/modules/contrib/src/spinimages.cpp b/modules/contrib/src/spinimages.cpp
index 727b0bb80b..63396845d3 100644
--- a/modules/contrib/src/spinimages.cpp
+++ b/modules/contrib/src/spinimages.cpp
@@ -442,11 +442,11 @@ void cv::Mesh3D::clearOctree(){ octree = Octree(); }
 
 float cv::Mesh3D::estimateResolution(float tryRatio)
 {
-    const size_t neighbors = 3;
-    const size_t minReasonable = 10;
+    const int neighbors = 3;
+    const int minReasonable = 10;
 
-    size_t tryNum = static_cast<size_t>(tryRatio * vtx.size());
-    tryNum = min(max(tryNum, minReasonable), vtx.size());
+    int tryNum = static_cast<int>(tryRatio * vtx.size());
+    tryNum = min(max(tryNum, minReasonable), (int)vtx.size());
 
     CvMat desc = cvMat((int)vtx.size(), 3, CV_32F, &vtx[0]);
     CvFeatureTree* tr = cvCreateKDTree(&desc);
@@ -456,7 +456,7 @@ float cv::Mesh3D::estimateResolution(float tryRatio)
     vector<Point3f> query;  
 
     RNG& rng = theRNG();          
-    for(size_t i = 0; i < tryNum; ++i)
+    for(int i = 0; i < tryNum; ++i)
         query.push_back(vtx[rng.next() % vtx.size()]);
         
     CvMat cvinds  = cvMat( (int)tryNum, neighbors, CV_32S,  &inds[0] );
@@ -466,7 +466,7 @@ float cv::Mesh3D::estimateResolution(float tryRatio)
     cvReleaseFeatureTree(tr);
 
     const int invalid_dist = -2;    
-    for(size_t i = 0; i < tryNum; ++i)
+    for(int i = 0; i < tryNum; ++i)
         if (inds[i] == -1)
             dist[i] = invalid_dist;
 
@@ -713,8 +713,8 @@ void cv::SpinImageModel::defaultParams()
 
 Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount, size_t yCount) const
 {
-    size_t spinNum = getSpinCount();
-    size_t num = min(spinNum, xCount * yCount);
+    int spinNum = (int)getSpinCount();
+    int num = min(spinNum, (int)(xCount * yCount));
 
     if (num == 0)
         return Mat();
@@ -722,11 +722,11 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
     RNG& rng = theRNG();    
 
     vector<Mat> spins;
-    for(size_t i = 0; i < num; ++i)
+    for(int i = 0; i < num; ++i)
         spins.push_back(getSpinImage( rng.next() % spinNum ).reshape(1, imageWidth));    
     
     if (separateScale)
-        for(size_t i = 0; i < num; ++i)
+        for(int i = 0; i < num; ++i)
         {
             double max;
             Mat spin8u;
@@ -737,14 +737,14 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
     else
     {    
         double totalMax = 0;
-        for(size_t i = 0; i < num; ++i)
+        for(int i = 0; i < num; ++i)
         {
             double m;
             minMaxLoc(spins[i], 0, &m);  
             totalMax = max(m, totalMax);
         }
 
-        for(size_t i = 0; i < num; ++i)
+        for(int i = 0; i < num; ++i)
         {
             Mat spin8u;
             spins[i].convertTo(spin8u, CV_8U, -255.0/totalMax, 255.0);
@@ -757,16 +757,16 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
     Mat result((int)(yCount * sz + (yCount - 1)), (int)(xCount * sz + (xCount - 1)), CV_8UC3);    
     result = colors[(static_cast<int64>(cvGetTickCount()/cvGetTickFrequency())/1000) % colors_mum];
 
-    size_t pos = 0;
-    for(size_t y = 0; y < yCount; ++y)
-        for(size_t x = 0; x < xCount; ++x)        
+    int pos = 0;
+    for(int y = 0; y < (int)yCount; ++y)
+        for(int x = 0; x < (int)xCount; ++x)        
             if (pos < num)
             {
-                int starty = (int)((y + 0) * sz + y);
-                int endy   = (int)((y + 1) * sz + y);
+                int starty = (y + 0) * sz + y;
+                int endy   = (y + 1) * sz + y;
 
-                int startx = (int)((x + 0) * sz + x);
-                int endx   = (int)((x + 1) * sz + x);
+                int startx = (x + 0) * sz + x;
+                int endx   = (x + 1) * sz + x;
 
                 Mat color;
                 cvtColor(spins[pos++], color, CV_GRAY2BGR);
diff --git a/modules/contrib/src/stereovar.cpp b/modules/contrib/src/stereovar.cpp
index cc6c53b60d..1197acc434 100755
--- a/modules/contrib/src/stereovar.cpp
+++ b/modules/contrib/src/stereovar.cpp
@@ -53,7 +53,7 @@
 
 namespace cv 
 {
-StereoVar::StereoVar() : levels(3), pyrScale(0.5), nIt(3), minDisp(0), maxDisp(16), poly_n(5), poly_sigma(1.2), fi(1000.0f), lambda(0.0f), penalization(PENALIZATION_TICHONOV), cycle(CYCLE_V), flags(USE_SMART_ID) 
+StereoVar::StereoVar() : levels(3), pyrScale(0.5), nIt(5), minDisp(0), maxDisp(16), poly_n(3), poly_sigma(0), fi(25.0f), lambda(0.03f), penalization(PENALIZATION_TICHONOV), cycle(CYCLE_V), flags(USE_SMART_ID | USE_AUTO_PARAMS) 
 {
 }
 
@@ -65,111 +65,174 @@ StereoVar::~StereoVar()
 {
 }
 
-static Mat diffX(Mat &img)
+static Mat diffX(Mat &src)
+{
+	register int x, y, cols = src.cols - 1;
+	Mat dst(src.size(), src.type());
+	for(y = 0; y < src.rows; y++){
+        const float* pSrc = src.ptr<float>(y);
+        float* pDst = dst.ptr<float>(y);
+#if CV_SSE2
+        for (x = 0; x <= cols - 8; x += 8) {
+            __m128 a0 = _mm_loadu_ps(pSrc + x);
+            __m128 b0 = _mm_loadu_ps(pSrc + x + 1);
+            __m128 a1 = _mm_loadu_ps(pSrc + x + 4);
+            __m128 b1 = _mm_loadu_ps(pSrc + x + 5);
+            b0 = _mm_sub_ps(b0, a0);
+            b1 = _mm_sub_ps(b1, a1);
+            _mm_storeu_ps(pDst + x, b0);
+            _mm_storeu_ps(pDst + x + 4, b1);
+        }
+#endif
+        for( ; x < cols; x++) pDst[x] = pSrc[x+1] - pSrc[x];
+        pDst[cols] = 0.f;
+    }
+    return dst;
+}
+
+static Mat getGradient(Mat &src)
 {
-	// TODO try pointers or assm
 	register int x, y;
-	Mat dst(img.size(), img.type());
+	Mat dst(src.size(), src.type());
 	dst.setTo(0);
-	for (x = 0; x < img.cols - 1; x++)
-		for (y = 0; y < img.rows; y++)
-			dst.at<float>(y, x) = img.at<float>(y, x + 1) - img.at<float>(y ,x);
+	for (y = 0; y < src.rows - 1; y++) {
+		float *pSrc = src.ptr<float>(y);
+		float *pSrcF = src.ptr<float>(y + 1);
+		float *pDst = dst.ptr<float>(y);
+		for (x = 0; x < src.cols - 1; x++)
+			pDst[x] = fabs(pSrc[x + 1] - pSrc[x]) + fabs(pSrcF[x] - pSrc[x]); 
+	}
 	return dst;
 }
 
-static Mat Gradient(Mat &img)
+static Mat getG_c(Mat &src, float l)
 {
-	Mat sobel, sobelX, sobelY;
-	img.copyTo(sobelX);
-	img.copyTo(sobelY);
-	Sobel(img, sobelX, sobelX.type(), 1, 0, 1);
-	Sobel(img, sobelY, sobelY.type(), 0, 1, 1);
-	sobelX = abs(sobelX);
-	sobelY = abs(sobelY);
-	add(sobelX, sobelY, sobel);
-	sobelX.release();
-	sobelY.release();
-	return sobel;
+	Mat dst(src.size(), src.type());
+	for (register int y = 0; y < src.rows; y++) {
+		float *pSrc = src.ptr<float>(y);
+		float *pDst = dst.ptr<float>(y);
+		for (register int x = 0; x < src.cols; x++)
+			pDst[x] = 0.5f*l / sqrtf(l*l + pSrc[x]*pSrc[x]);
+	}
+	return dst;
 }
 
-static float g_c(Mat z, int x, int y, float l)
+static Mat getG_p(Mat &src, float l)
 {
-	return 0.5f*l / sqrtf(l*l + z.at<float>(y,x)*z.at<float>(y,x));
-}
-
-static float g_p(Mat z, int x, int y, float l)
-{
-	return 0.5f*l*l / (l*l + z.at<float>(y,x)*z.at<float>(y,x)) ;
+	Mat dst(src.size(), src.type());
+	for (register int y = 0; y < src.rows; y++) {
+		float *pSrc = src.ptr<float>(y);
+		float *pDst = dst.ptr<float>(y);
+		for (register int x = 0; x < src.cols; x++)
+			pDst[x] = 0.5f*l*l / (l*l + pSrc[x]*pSrc[x]);
+	}
+	return dst;
 }
 
 void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
 {
 	register int n, x, y;
 	float gl = 1, gr = 1, gu = 1, gd = 1, gc = 4;
+	Mat g_c, g_p;
 	Mat U; 
-	Mat Sobel;
 	u.copyTo(U);
 
 	int		N = nIt;
 	float	l = lambda;
 	float	Fi = fi;
 
-	double scale = pow(pyrScale, (double) level);
-	if (flags & USE_SMART_ID) {										
+	
+	if (flags & USE_SMART_ID) {
+		double scale = pow(pyrScale, (double) level) * (1 + pyrScale);	
 		N = (int) (N / scale);
-		Fi /= (float) scale;
-		l *= (float) scale;
 	}
+
+	double scale = pow(pyrScale, (double) level);
+	Fi /= (float) scale;
+	l *= (float) scale;
+
+	int width	= u.cols - 1;
+	int height	= u.rows - 1;
 	for (n = 0; n < N; n++) {
-		if (penalization != PENALIZATION_TICHONOV) {if(!Sobel.empty()) Sobel.release(); Sobel = Gradient(U);}
-		for (x = 1; x < u.cols - 1; x++) {
-			for (y = 1 ; y < u.rows - 1; y++) {
+		if (penalization != PENALIZATION_TICHONOV) {
+			Mat gradient = getGradient(U);
+			switch (penalization) {
+				case PENALIZATION_CHARBONNIER:	g_c = getG_c(gradient, l); break;
+				case PENALIZATION_PERONA_MALIK: g_p = getG_p(gradient, l); break;
+			}
+			gradient.release();
+		}
+		for (y = 1 ; y < height; y++) {
+			float *pU	= U.ptr<float>(y);
+			float *pUu	= U.ptr<float>(y + 1);
+			float *pUd	= U.ptr<float>(y - 1);
+			float *pu	= u.ptr<float>(y);
+			float *pI1	= I1.ptr<float>(y);
+			float *pI2	= I2.ptr<float>(y);
+			float *pI2x = I2x.ptr<float>(y);
+			float *pG_c = NULL, *pG_cu = NULL, *pG_cd = NULL;
+			float *pG_p = NULL, *pG_pu = NULL, *pG_pd = NULL;
+			switch (penalization) {
+				case PENALIZATION_CHARBONNIER:	
+					pG_c	= g_c.ptr<float>(y); 
+					pG_cu	= g_c.ptr<float>(y + 1); 
+					pG_cd	= g_c.ptr<float>(y - 1); 
+					break;
+				case PENALIZATION_PERONA_MALIK: 
+					pG_p	= g_p.ptr<float>(y); 
+					pG_pu	= g_p.ptr<float>(y + 1); 
+					pG_pd	= g_p.ptr<float>(y - 1); 
+					break;
+			}
+			for (x = 1; x < width; x++) {
 				switch (penalization) {
 					case PENALIZATION_CHARBONNIER:
-						gc = g_c(Sobel, x, y, l);
-						gl = gc + g_c(Sobel, x - 1, y, l);
-						gr = gc + g_c(Sobel, x + 1, y, l);
-						gu = gc + g_c(Sobel, x, y + 1, l);
-						gd = gc + g_c(Sobel, x, y - 1, l);
-						gc = gl + gr + gu + gd;
+						gc = pG_c[x];
+						gl = gc + pG_c[x - 1];
+						gr = gc + pG_c[x + 1];
+						gu = gc + pG_cu[x];
+						gd = gc + pG_cd[x];
+						gc = gl + gr + gu + gd;						
 						break;
 					case PENALIZATION_PERONA_MALIK:
-						gc = g_p(Sobel, x, y, l);
-						gl = gc + g_p(Sobel, x - 1, y, l);
-						gr = gc + g_p(Sobel, x + 1, y, l);
-						gu = gc + g_p(Sobel, x, y + 1, l);
-						gd = gc + g_p(Sobel, x, y - 1, l);
+						gc = pG_p[x];
+						gl = gc + pG_p[x - 1];
+						gr = gc + pG_p[x + 1];
+						gu = gc + pG_pu[x];
+						gd = gc + pG_pd[x];
 						gc = gl + gr + gu + gd;
 						break;
 				}
 
 				float fi = Fi;
 				if (maxDisp > minDisp) {
-					if (U.at<float>(y,x) > maxDisp * scale) {fi*=1000; U.at<float>(y,x) = static_cast<float>(maxDisp * scale);} 
-					if (U.at<float>(y,x) < minDisp * scale) {fi*=1000; U.at<float>(y,x) = static_cast<float>(minDisp * scale);} 
+					if (pU[x] > maxDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);} 
+					if (pU[x] < minDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);} 
 				}
 
-				int A = (int) (U.at<float>(y,x));
-				int neg = 0; if (U.at<float>(y,x) <= 0) neg = -1;
+				int A = static_cast<int>(pU[x]);
+				int neg = 0; if (pU[x] <= 0) neg = -1;
 
-				if (x + A >= u.cols)
-					u.at<float>(y, x) = U.at<float>(y, u.cols - A - 1);
+				if (x + A > width)
+					pu[x] = pU[width - A];
 				else if (x + A + neg < 0)
-					u.at<float>(y, x) = U.at<float>(y, - A + 2);
+					pu[x] = pU[- A + 2];
 				else { 
-					u.at<float>(y, x) = A + (I2x.at<float>(y, x + A + neg) * (I1.at<float>(y, x) - I2.at<float>(y, x + A))
-										  + fi * (gr * U.at<float>(y, x + 1) + gl * U.at<float>(y, x - 1) + gu * U.at<float>(y + 1, x) + gd * U.at<float>(y - 1, x) - gc * A)) 
-										  / (I2x.at<float>(y, x + A + neg) * I2x.at<float>(y, x + A + neg) + gc * fi) ; 
+					pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A])
+							  + fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A)) 
+							  / (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * fi) ; 
 				}
-			}//y
+			}// x
+			pu[0] = pu[1];
+			pu[width] = pu[width - 1];
+		}// y
+		for (x = 0; x <= width; x++) {
 			u.at<float>(0, x) = u.at<float>(1, x);
-			u.at<float>(u.rows - 1, x) = u.at<float>(u.rows - 2, x);
-		}//x
-		for (y = 0; y < u.rows; y++) {
-			u.at<float>(y, 0) = u.at<float>(y, 1);
-			u.at<float>(y, u.cols - 1) = u.at<float>(y, u.cols - 2);
+			u.at<float>(height, x) = u.at<float>(height - 1, x);
 		}
 		u.copyTo(U);
+		if (!g_c.empty()) g_c.release();
+		if (!g_p.empty()) g_p.release();
 	}//n
 }
 
@@ -251,15 +314,43 @@ void StereoVar::FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
 	u_h.release();
 
 	level--;
+	if ((flags & USE_AUTO_PARAMS) && (level < levels / 3)) { 
+		penalization = PENALIZATION_PERONA_MALIK;
+		fi *= 100;
+		flags -= USE_AUTO_PARAMS;
+		autoParams();
+	}
 	if (flags & USE_MEDIAN_FILTERING) medianBlur(u, u, 3);
 	if (level >= 0) FMG(I1, I2, I2x, u, level);
 }
 
+void StereoVar::autoParams()
+{	
+	int maxD = MAX(labs(maxDisp), labs(minDisp));
+	
+	if (!maxD) pyrScale = 0.85;
+	else if (maxD < 8) pyrScale = 0.5;
+	else if (maxD < 64) pyrScale = 0.5 + static_cast<double>(maxD - 8) * 0.00625;
+	else pyrScale = 0.85;
+	
+	if (maxD) {
+		levels = 0;
+		while ( pow(pyrScale, levels) * maxD > 1.5) levels ++;
+		levels++;
+	}
+
+	switch(penalization) {
+		case PENALIZATION_TICHONOV: cycle = CYCLE_V; break;
+		case PENALIZATION_CHARBONNIER: cycle = CYCLE_O; break;
+		case PENALIZATION_PERONA_MALIK: cycle = CYCLE_O; break;
+	}
+}
+
 void StereoVar::operator ()( const Mat& left, const Mat& right, Mat& disp )
 {
 	CV_Assert(left.size() == right.size() && left.type() == right.type());
 	CvSize imgSize = left.size();
-	int MaxD = MAX(std::abs(minDisp), std::abs(maxDisp)); 
+	int MaxD = MAX(labs(minDisp), labs(maxDisp)); 
 	int SignD = 1; if (MIN(minDisp, maxDisp) < 0) SignD = -1;
 	if (minDisp >= maxDisp) {MaxD = 256; SignD = 1;}
 		
@@ -290,6 +381,11 @@ void StereoVar::operator ()( const Mat& left, const Mat& right, Mat& disp )
 		GaussianBlur(rightgray, rightgray, cvSize(poly_n, poly_n), poly_sigma);
 	}
 		
+	if (flags & USE_AUTO_PARAMS) {
+		penalization = PENALIZATION_TICHONOV;
+		autoParams();
+	}
+
 	Mat I1, I2;
 	leftgray.convertTo(I1, CV_32FC1);
 	rightgray.convertTo(I2, CV_32FC1);
diff --git a/modules/contrib/src/templatebuffer.hpp b/modules/contrib/src/templatebuffer.hpp
new file mode 100644
index 0000000000..14bcea9052
--- /dev/null
+++ b/modules/contrib/src/templatebuffer.hpp
@@ -0,0 +1,520 @@
+/*#******************************************************************************
+** 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.
+** 
+** 
+** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.
+** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.
+** 
+** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)
+** 
+**  Creation - enhancement process 2007-2011
+**      Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France
+** 
+** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).
+** Refer to the following research paper for more information:
+** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011
+** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:
+** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.
+** 
+** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :
+** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:
+** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007
+** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.
+** ====> more informations in the above cited Jeanny Heraults's book.
+** 
+**                          License Agreement
+**               For Open Source Computer Vision Library
+** 
+** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.
+** 
+**               For Human Visual System tools (hvstools)
+** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, all rights reserved.
+** 
+** Third party copyrights are property of their respective owners.
+** 
+** Redistribution and use in source and binary forms, with or without modification,
+** are permitted provided that the following conditions are met:
+** 
+** * Redistributions of source code must retain the above copyright notice,
+**    this list of conditions and the following disclaimer.
+** 
+** * Redistributions in binary form must reproduce the above copyright notice,
+**    this list of conditions and the following disclaimer in the documentation
+**    and/or other materials provided with the distribution.
+** 
+** * The name of the copyright holders may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+** 
+** This software is provided by the copyright holders and contributors "as is" and
+** any express or implied warranties, including, but not limited to, the implied
+** warranties of merchantability and fitness for a particular purpose are disclaimed.
+** In no event shall the Intel Corporation or contributors be liable for any direct,
+** indirect, incidental, special, exemplary, or consequential damages
+** (including, but not limited to, procurement of substitute goods or services;
+** loss of use, data, or profits; or business interruption) however caused
+** and on any theory of liability, whether in contract, strict liability,
+** or tort (including negligence or otherwise) arising in any way out of
+** the use of this software, even if advised of the possibility of such damage.
+*******************************************************************************/
+
+#ifndef __TEMPLATEBUFFER_HPP__
+#define __TEMPLATEBUFFER_HPP__
+
+#include <valarray>
+#include <cstdlib>
+#include <iostream>
+#include <cmath>
+
+//#define __TEMPLATEBUFFERDEBUG //define TEMPLATEBUFFERDEBUG in order to display debug information
+
+namespace cv
+{
+/**
+* @class TemplateBuffer
+* @brief this class is a simple template memory buffer which contains basic functions to get information on or normalize the buffer content
+* note that thanks to the parent STL template class "valarray", it is possible to perform easily operations on the full array such as addition, product etc.
+* @author Alexandre BENOIT (benoit.alexandre.vision@gmail.com), helped by Gelu IONESCU (gelu.ionescu@lis.inpg.fr)
+* creation date: september 2007
+*/
+template <class type> class TemplateBuffer : public std::valarray<type>
+{
+public:
+
+	/**
+	* constructor for monodimensional array
+	* @param dim: the size of the vector
+	*/
+	TemplateBuffer(const size_t dim=0)
+	: std::valarray<type>((type)0, dim)
+	  {
+		_NBrows=1;
+		_NBcolumns=dim;
+		_NBdepths=1;
+		_NBpixels=dim;
+		_doubleNBpixels=2*dim;
+	  }
+
+	/**
+	* constructor by copy for monodimensional array
+	* @param pVal: the pointer to a buffer to copy
+	* @param dim: the size of the vector
+	*/
+	TemplateBuffer(const type* pVal, const size_t dim)
+	: std::valarray<type>(pVal, dim)
+	  {
+		_NBrows=1;
+		_NBcolumns=dim;
+		_NBdepths=1;
+		_NBpixels=dim;
+		_doubleNBpixels=2*dim;
+	  }
+
+	/**
+	* constructor for bidimensional array
+	* @param dimRows: the size of the vector
+	* @param dimColumns: the size of the vector
+	* @param depth: the number of layers of the buffer in its third dimension (3 of color images, 1 for gray images.
+	*/
+	TemplateBuffer(const size_t dimRows, const size_t dimColumns, const size_t depth=1)
+	: std::valarray<type>((type)0, dimRows*dimColumns*depth)
+	  {
+#ifdef TEMPLATEBUFFERDEBUG
+		std::cout<<"TemplateBuffer::TemplateBuffer: new buffer, size="<<dimRows<<", "<<dimColumns<<", "<<depth<<"valarraySize="<<this->size()<<std::endl;
+#endif
+		_NBrows=dimRows;
+		_NBcolumns=dimColumns;
+		_NBdepths=depth;
+		_NBpixels=dimRows*dimColumns;
+		_doubleNBpixels=2*dimRows*dimColumns;
+		//_createTableIndex();
+#ifdef TEMPLATEBUFFERDEBUG
+		std::cout<<"TemplateBuffer::TemplateBuffer: construction successful"<<std::endl;
+#endif
+
+	  }
+
+	/**
+	* copy constructor
+	* @param toCopy
+	* @return thenconstructed instance
+	*emplateBuffer(const TemplateBuffer &toCopy)
+	:_NBrows(toCopy.getNBrows()),_NBcolumns(toCopy.getNBcolumns()),_NBdepths(toCopy.getNBdephs()), _NBpixels(toCopy.getNBpixels()), _doubleNBpixels(toCopy.getNBpixels()*2)
+	//std::valarray<type>(toCopy)
+	{
+	memcpy(Buffer(), toCopy.Buffer(), this->size());
+	}*/
+	/**
+	* destructor
+	*/
+	virtual ~TemplateBuffer()
+	{
+#ifdef TEMPLATEBUFFERDEBUG
+		std::cout<<"~TemplateBuffer"<<std::endl;
+#endif
+	}
+
+	/**
+	* delete the buffer content (set zeros)
+	*/
+	inline void setZero(){std::valarray<type>::operator=(0);};//memset(Buffer(), 0, sizeof(type)*_NBpixels);};
+
+	/**
+	* @return the numbers of rows (height) of the images used by the object
+	*/
+	inline unsigned int getNBrows(){return (unsigned int)_NBrows;};
+
+	/**
+	* @return the numbers of columns (width) of the images used by the object
+	*/
+	inline unsigned int getNBcolumns(){return (unsigned int)_NBcolumns;};
+
+	/**
+	* @return the numbers of pixels (width*height) of the images used by the object
+	*/
+	inline unsigned int getNBpixels(){return (unsigned int)_NBpixels;};
+
+	/**
+	* @return the numbers of pixels (width*height) of the images used by the object
+	*/
+	inline unsigned int getDoubleNBpixels(){return (unsigned int)_doubleNBpixels;};
+
+	/**
+	* @return the numbers of depths (3rd dimension: 1 for gray images, 3 for rgb images) of the images used by the object
+	*/
+	inline unsigned int getDepthSize(){return (unsigned int)_NBdepths;};
+
+	/**
+	* resize the buffer and recompute table index etc.
+	*/
+	void resizeBuffer(const size_t dimRows, const size_t dimColumns, const size_t depth=1)
+	{
+		this->resize(dimRows*dimColumns*depth);
+		_NBrows=dimRows;
+		_NBcolumns=dimColumns;
+		_NBdepths=depth;
+		_NBpixels=dimRows*dimColumns;
+		_doubleNBpixels=2*dimRows*dimColumns;
+	}
+
+	inline TemplateBuffer<type> & operator=(const std::valarray<type> &b)
+	{
+		//std::cout<<"TemplateBuffer<type> & operator= affect vector: "<<std::endl;
+		std::valarray<type>::operator=(b);
+		return *this;
+	}
+
+	inline TemplateBuffer<type> & operator=(const type &b)
+	{
+		//std::cout<<"TemplateBuffer<type> & operator= affect value: "<<b<<std::endl;
+		std::valarray<type>::operator=(b);
+		return *this;
+	}
+
+	/*  inline const type  &operator[](const unsigned int &b)
+  {
+	  return (*this)[b];
+  }
+	 */
+	/**
+	* @return the buffer adress in non const mode
+	*/
+	inline type*    Buffer()            {    return &(*this)[0];    }
+
+	///////////////////////////////////////////////////////
+	// Standard Image manipulation functions
+
+	/**
+	* standard 0 to 255 image normalization function
+	* @param inputOutputBuffer: the image to be normalized (rewrites the input), if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param nbPixels: specifies the number of pixel on which the normalization should be performed, if 0, then all pixels specified in the constructor are processed
+	* @param maxOutputValue: the maximum output value
+	*/
+	static void normalizeGrayOutput_0_maxOutputValue(type *inputOutputBuffer, const size_t nbPixels, const type maxOutputValue=(type)255.0);
+
+	/**
+	* standard 0 to 255 image normalization function
+	* @param inputOutputBuffer: the image to be normalized (rewrites the input), if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param nbPixels: specifies the number of pixel on which the normalization should be performed, if 0, then all pixels specified in the constructor are processed
+	* @param maxOutputValue: the maximum output value
+	*/
+	void normalizeGrayOutput_0_maxOutputValue(const type maxOutputValue=(type)255.0){normalizeGrayOutput_0_maxOutputValue(this->Buffer(), this->size(), maxOutputValue);};
+
+	/**
+	* sigmoide image normalization function (saturates min and max values)
+	* @param meanValue: specifies the mean value of th pixels to be processed
+	* @param sensitivity: strenght of the sigmoide
+	* @param inputPicture: the image to be normalized if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param outputBuffer: the ouput buffer on which the result is writed, if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param maxOutputValue: the maximum output value
+	*/
+	static void normalizeGrayOutputCentredSigmoide(const type meanValue, const type sensitivity, const type maxOutputValue, type *inputPicture, type *outputBuffer, const unsigned int nbPixels);
+
+	/**
+	* sigmoide image normalization function on the current buffer (saturates min and max values)
+	* @param meanValue: specifies the mean value of th pixels to be processed
+	* @param sensitivity: strenght of the sigmoide
+	* @param maxOutputValue: the maximum output value
+	*/
+	inline void normalizeGrayOutputCentredSigmoide(const type meanValue=(type)0.0, const type sensitivity=(type)2.0, const type maxOutputValue=(type)255.0){normalizeGrayOutputCentredSigmoide(meanValue, sensitivity, 255.0, this->Buffer(), this->Buffer(), this->getNBpixels()), maxOutputValue;};
+
+	/**
+	* sigmoide image normalization function (saturates min and max values), in this function, the sigmoide is centered on low values (high saturation of the medium and high values
+	* @param inputPicture: the image to be normalized if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param outputBuffer: the ouput buffer on which the result is writed, if no parameter, then, the built in buffer reachable by getOutput() function is normalized
+	* @param sensitivity: strenght of the sigmoide
+	* @param maxOutputValue: the maximum output value
+	*/
+	void normalizeGrayOutputNearZeroCentreredSigmoide(type *inputPicture=(type*)NULL, type *outputBuffer=(type*)NULL, const type sensitivity=(type)40, const type maxOutputValue=(type)255.0);
+
+	/**
+	* center and reduct the image (image-mean)/std
+	* @param inputOutputBuffer: the image to be normalized if no parameter, the result is rewrited on it
+	*/
+	void centerReductImageLuminance(type *inputOutputBuffer=(type*)NULL);
+
+	/**
+	* @return standard deviation of the buffer
+	*/
+	const double getStandardDeviation()
+	{
+		double standardDeviation=0;
+		double meanValue=getMean();
+
+		type *bufferPTR=Buffer();
+		for (unsigned int i=0;i<this->size();++i)
+		{
+			double diff=(*(bufferPTR++)-meanValue);
+			standardDeviation+=diff*diff;
+		}
+		return sqrt(standardDeviation/this->size());
+	};
+
+	/**
+	* Clip buffer histogram
+	* @param minRatio: the minimum ratio of the lower pixel values, range=[0,1] and lower than maxRatio
+	* @param maxRatio: the aximum ratio of the higher pixel values, range=[0,1] and higher than minRatio
+	*/
+	void clipHistogram(double minRatio, double maxRatio, double maxOutputValue)
+	{
+
+		if (minRatio>=maxRatio)
+		{
+			std::cerr<<"TemplateBuffer::clipHistogram: minRatio must be inferior to maxRatio, buffer unchanged"<<std::endl;
+			return;
+		}
+
+		/*    minRatio=min(max(minRatio, 1.0),0.0);
+    maxRatio=max(max(maxRatio, 0.0),1.0);
+		 */
+
+		// find the pixel value just above the threshold
+		const double maxThreshold=this->max()*maxRatio;
+		const double minThreshold=(this->max()-this->min())*minRatio+this->min();
+
+		type *bufferPTR=this->Buffer();
+
+		double deltaH=maxThreshold;
+		double deltaL=maxThreshold;
+
+		double updatedHighValue=maxThreshold;
+		double updatedLowValue=maxThreshold;
+
+		for (unsigned int i=0;i<this->size();++i)
+		{
+			double curentValue=(double)*(bufferPTR++);
+
+			// updating "closest to the high threshold" pixel value
+			double highValueTest=maxThreshold-curentValue;
+			if (highValueTest>0)
+			{
+				if (deltaH>highValueTest)
+				{
+					deltaH=highValueTest;
+					updatedHighValue=curentValue;
+				}
+			}
+
+			// updating "closest to the low threshold" pixel value
+			double lowValueTest=curentValue-minThreshold;
+			if (lowValueTest>0)
+			{
+				if (deltaL>lowValueTest)
+				{
+					deltaL=lowValueTest;
+					updatedLowValue=curentValue;
+				}
+			}
+		}
+
+		std::cout<<"Tdebug"<<std::endl;
+		std::cout<<"deltaL="<<deltaL<<", deltaH="<<deltaH<<std::endl;
+		std::cout<<"this->max()"<<this->max()<<"maxThreshold="<<maxThreshold<<"updatedHighValue="<<updatedHighValue<<std::endl;
+		std::cout<<"this->min()"<<this->min()<<"minThreshold="<<minThreshold<<"updatedLowValue="<<updatedLowValue<<std::endl;
+		// clipping values outside than the updated thresholds
+		bufferPTR=this->Buffer();
+		for (unsigned int i=0;i<this->size();++i, ++bufferPTR)
+		{
+			if (*bufferPTR<updatedLowValue)
+				*bufferPTR=updatedLowValue;
+			else if (*bufferPTR>updatedHighValue)
+				*bufferPTR=updatedHighValue;
+		}
+
+		normalizeGrayOutput_0_maxOutputValue(this->Buffer(), this->size(), maxOutputValue);
+
+	}
+
+	/**
+	* @return the mean value of the vector
+	*/
+	inline const double getMean(){return this->sum()/this->size();};
+
+protected:
+	size_t _NBrows;
+	size_t _NBcolumns;
+	size_t _NBdepths;
+	size_t _NBpixels;
+	size_t _doubleNBpixels;
+	// utilities
+	static type _abs(const type x);
+
+};
+
+///////////////////////////////////////////////////////////////////////
+/// normalize output between 0 and 255, can be applied on images of different size that the declared size if nbPixels parameters is setted up;
+template <class type>
+void TemplateBuffer<type>::normalizeGrayOutput_0_maxOutputValue(type *inputOutputBuffer, const size_t processedPixels, const type maxOutputValue)
+{
+	type maxValue=inputOutputBuffer[0], minValue=inputOutputBuffer[0];
+
+	// get the min and max value
+	register type *inputOutputBufferPTR=inputOutputBuffer;
+	for (register size_t j = 0; j<processedPixels; ++j)
+	{
+		type pixValue = *(inputOutputBufferPTR++);
+		if (maxValue < pixValue)
+			maxValue = pixValue;
+		else if (minValue > pixValue)
+			minValue = pixValue;
+	}
+	// change the range of the data to 0->255
+
+	type factor = maxOutputValue/(maxValue-minValue);
+	type offset = -1.0*minValue*factor;
+
+	inputOutputBufferPTR=inputOutputBuffer;
+	for (register size_t j = 0; j < processedPixels; ++j, ++inputOutputBufferPTR)
+		*inputOutputBufferPTR=*(inputOutputBufferPTR)*factor+offset;
+
+}
+// normalize data with a sigmoide close to 0 (saturates values for those superior to 0)
+template <class type>
+void TemplateBuffer<type>::normalizeGrayOutputNearZeroCentreredSigmoide(type *inputBuffer, type *outputBuffer, const type sensitivity, const type maxOutputValue)
+{
+	if (inputBuffer==NULL)
+		inputBuffer=Buffer();
+	if (outputBuffer==NULL)
+		outputBuffer=Buffer();
+
+	type X0cube=sensitivity*sensitivity*sensitivity;
+
+	register type *inputBufferPTR=inputBuffer;
+	register type *outputBufferPTR=outputBuffer;
+
+	for (register size_t j = 0; j < _NBpixels; ++j, ++inputBufferPTR)
+	{
+
+		type currentCubeLuminance=*inputBufferPTR**inputBufferPTR**inputBufferPTR;
+		*(outputBufferPTR++)=maxOutputValue*currentCubeLuminance/(currentCubeLuminance+X0cube);
+	}
+}
+
+// normalize and adjust luminance with a centered to 128 sigmode
+template <class type>
+void TemplateBuffer<type>::normalizeGrayOutputCentredSigmoide(const type meanValue, const type sensitivity, const type maxOutputValue, type *inputBuffer, type *outputBuffer, const unsigned int nbPixels)
+{
+
+	if (sensitivity==1.0)
+	{
+		std::cerr<<"TemplateBuffer::TemplateBuffer<type>::normalizeGrayOutputCentredSigmoide error: 2nd parameter (sensitivity) must not equal 0, copying original data..."<<std::endl;
+		memcpy(outputBuffer, inputBuffer, sizeof(type)*nbPixels);
+		return;
+	}
+
+	type X0=maxOutputValue/(sensitivity-(type)1.0);
+
+	register type *inputBufferPTR=inputBuffer;
+	register type *outputBufferPTR=outputBuffer;
+
+	for (register size_t j = 0; j < nbPixels; ++j, ++inputBufferPTR)
+		*(outputBufferPTR++)=(meanValue+(meanValue+X0)*(*(inputBufferPTR)-meanValue)/(_abs(*(inputBufferPTR)-meanValue)+X0));
+
+}
+
+// center and reduct the image (image-mean)/std
+template <class type>
+void TemplateBuffer<type>::centerReductImageLuminance(type *inputOutputBuffer)
+{
+	// if outputBuffer unsassigned, the rewrite the buffer
+	if (inputOutputBuffer==NULL)
+		inputOutputBuffer=Buffer();
+	type meanValue=0, stdValue=0;
+
+	// compute mean value
+	for (register size_t j = 0; j < _NBpixels; ++j)
+		meanValue+=inputOutputBuffer[j];
+	meanValue/=((type)_NBpixels);
+
+	// compute std value
+	register type *inputOutputBufferPTR=inputOutputBuffer;
+	for (size_t index=0;index<_NBpixels;++index)
+	{
+		type inputMinusMean=*(inputOutputBufferPTR++)-meanValue;
+		stdValue+=inputMinusMean*inputMinusMean;
+	}
+
+	stdValue=sqrt(stdValue/((type)_NBpixels));
+	// adjust luminance in regard of mean and std value;
+	inputOutputBufferPTR=inputOutputBuffer;
+	for (size_t index=0;index<_NBpixels;++index, ++inputOutputBufferPTR)
+		*inputOutputBufferPTR=(*(inputOutputBufferPTR)-meanValue)/stdValue;
+}
+
+
+template <class type>
+type TemplateBuffer<type>::_abs(const type x)
+{
+
+	if (x>0)
+		return x;
+	else
+		return -x;
+}
+
+template < >
+inline int TemplateBuffer<int>::_abs(const int x)
+{
+	return std::abs(x);
+}
+template < >
+inline double TemplateBuffer<double>::_abs(const double x)
+{
+	return std::fabs(x);
+}
+
+template < >
+inline float TemplateBuffer<float>::_abs(const float x)
+{
+	return std::fabs(x);
+}
+
+}
+#endif
+
+
+
diff --git a/modules/core/doc/basic_structures.rst b/modules/core/doc/basic_structures.rst
index 24c9646120..208554c0d5 100644
--- a/modules/core/doc/basic_structures.rst
+++ b/modules/core/doc/basic_structures.rst
@@ -113,7 +113,7 @@ Rect\_
 ------
 .. ocv:class:: Rect_
 
-Template class for 2D rectangles, described by the following parameters::
+Template class for 2D rectangles, described by the following parameters:
 
 * Coordinates of the top-left corner. This is a default interpretation of ``Rect_::x`` and ``Rect_::y`` in OpenCV. Though, in your algorithms you may count ``x`` and ``y`` from the bottom-left corner. 
 * Rectangle width and height.
@@ -215,7 +215,7 @@ If you need a more flexible type, use :ocv:class:`Mat` . The elements of the mat
               7, 8, 9);
     cout << sum(Mat(m*m.t())) << endl;
 
-	
+    
 Vec
 ---
 .. ocv:class:: Vec
@@ -303,6 +303,8 @@ The static method ``Range::all()`` returns a special variable that means "the wh
     }
 
 
+.. _Ptr: 
+
 Ptr
 ---
 .. ocv:class:: Ptr
@@ -652,50 +654,86 @@ Matrix Expressions
 ------------------
 
 This is a list of implemented matrix operations that can be combined in arbitrary complex expressions
-(here
-*A*,*B*
-stand for matrices ( ``Mat`` ),
-*s*
-for a scalar ( ``Scalar`` ),
-:math:`\alpha` for a real-valued scalar ( ``double`` )):
+(here ``A``, ``B`` stand for matrices ( ``Mat`` ), ``s`` for a scalar ( ``Scalar`` ),
+``alpha`` for a real-valued scalar ( ``double`` )):
 
 *
     Addition, subtraction, negation:
-    :math:`A \pm B,\;A \pm s,\;s \pm A,\;-A` *
-    scaling:
-    :math:`A*\alpha`,    :math:`A*\alpha` *
-    per-element multiplication and division:
-    :math:`A.mul(B), A/B, \alpha/A` *
-    matrix multiplication:
-    :math:`A*B` *
-    transposition:
-    :math:`A.t() \sim A^t` *
-    matrix inversion and pseudo-inversion, solving linear systems and least-squares problems:
+    ``A+B, A-B, A+s, A-s, s+A, s-A, -A``
+    
+*   
+    Scaling:
+    ``A*alpha``
+    
+*
+    Per-element multiplication and division:
+    ``A.mul(B), A/B, alpha/A``
+    
+*
+    Matrix multiplication:
+    ``A*B``
+    
+*
+    Transposition:
+    ``A.t()`` (means ``A``\ :sup:`T`)
+    
+*
+    Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems:
 
-    :math:`A.inv([method]) \sim A^{-1}, A.inv([method])*B \sim X:\,AX=B`
+    ``A.inv([method])`` (~ ``A``\ :sup:`-1`) ``,   A.inv([method])*B`` (~ ``X: AX=B``)
     
 *
     Comparison:
-    :math:`A\gtreqqless B,\;A \ne B,\;A \gtreqqless \alpha,\;A \ne \alpha`. The result of comparison is an 8-bit single channel mask whose elements are set to 255 (if the particular element or pair of elements satisfy the condition) or 0.
+    ``A cmpop B, A cmpop alpha, alpha cmpop A``, where ``cmpop`` is one of ``:  >, >=, ==, !=, <=, <``. The result of comparison is an 8-bit single channel mask whose elements are set to 255 (if the particular element or pair of elements satisfy the condition) or 0.
 
 *
-    Bitwise logical operations: ``A & B, A & s, A | B, A | s, A textasciicircum B, A textasciicircum s, ~ A`` *
-    element-wise minimum and maximum:
-    :math:`min(A, B), min(A, \alpha), max(A, B), max(A, \alpha)` *
-    element-wise absolute value:
-    :math:`abs(A)` *
-    cross-product, dot-product:
-    :math:`A.cross(B), A.dot(B)` *
-    any function of matrix or matrices and scalars that returns a matrix or a scalar, such as ``norm``, ``mean``, ``sum``, ``countNonZero``, ``trace``, ``determinant``, ``repeat``, and others.
+    Bitwise logical operations: ``A logicop B, A logicop s, s logicop A, ~A``, where ``logicop`` is one of ``:  &, |, ^``.
+    
+*
+    Element-wise minimum and maximum:
+    ``min(A, B), min(A, alpha), max(A, B), max(A, alpha)``
+    
+*
+    Element-wise absolute value:
+    ``abs(A)``
+    
+*
+    Cross-product, dot-product:
+    ``A.cross(B)``
+    ``A.dot(B)``
+    
+*
+    Any function of matrix or matrices and scalars that returns a matrix or a scalar, such as ``norm``, ``mean``, ``sum``, ``countNonZero``, ``trace``, ``determinant``, ``repeat``, and others.
 
 *
-    Matrix initializers ( ``eye(), zeros(), ones()``     ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :ocv:class:`Mat`     description).
+    Matrix initializers ( ``Mat::eye(), Mat::zeros(), Mat::ones()`` ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :ocv:class:`Mat` description).
 
 *
     ``Mat_<destination_type>()`` constructors to cast the result to the proper type.
 
 .. note:: Comma-separated initializers and probably some other operations may require additional explicit ``Mat()`` or ``Mat_<T>()`` constuctor calls to resolve a possible ambiguity.
 
+Here are examples of matrix expressions:
+
+::
+
+    // compute pseudo-inverse of A, equivalent to A.inv(DECOMP_SVD)
+    SVD svd(A);
+    Mat pinvA = svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t();
+    
+    // compute the new vector of parameters in the Levenberg-Marquardt algorithm
+    x -= (A.t()*A + lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err);
+    
+    // sharpen image using "unsharp mask" algorithm
+    Mat blurred; double sigma = 1, threshold = 5, amount = 1;
+    GaussianBlur(img, blurred, Size(), sigma, sigma);
+    Mat lowConstrastMask = abs(img - blurred) < threshold;
+    Mat sharpened = img*(1+amount) + blurred*(-amount);
+    img.copyTo(sharpened, lowContrastMask);
+    
+..
+
+
 Below is the formal description of the ``Mat`` methods.
 
 Mat::Mat
@@ -800,7 +838,7 @@ Provides matrix assignment operators.
 
 .. ocv:function:: Mat& Mat::operator = (const MatExpr_Base& expr)
 
-.. ocv:function:: Mat& operator = (const Scalar& s)
+.. ocv:function:: Mat& Mat::operator = (const Scalar& s)
 
     :param m: Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via  :ocv:func:`Mat::release` .
 
@@ -853,7 +891,7 @@ The method makes a new header for the specified matrix row and returns it. This
         A.row(i) = A.row(j) + 0;
 
         // this is a bit longe, but the recommended method.
-        Mat Ai = A.row(i); M.row(j).copyTo(Ai);
+        A.row(j).copyTo(A.row(i));
 
 Mat::col
 ------------
@@ -875,9 +913,9 @@ Creates a matrix header for the specified row span.
 
 .. ocv:function:: Mat Mat::rowRange(const Range& r) const
 
-    :param startrow: A 0-based start index of the row span.
+    :param startrow: An inclusive 0-based start index of the row span.
 
-    :param endrow: A 0-based ending index of the row span.
+    :param endrow: An exclusive 0-based ending index of the row span.
 
     :param r: :ocv:class:`Range`  structure containing both the start and the end indices.
 
@@ -893,9 +931,9 @@ Creates a matrix header for the specified row span.
 
 .. ocv:function:: Mat Mat::colRange(const Range& r) const
 
-    :param startcol: A 0-based start index of the column span.
+    :param startcol: An inclusive 0-based start index of the column span.
 
-    :param endcol: A 0-based ending index of the column span.
+    :param endcol: An exclusive 0-based ending index of the column span.
 
     :param r: :ocv:class:`Range`  structure containing both the start and the end indices.
 
@@ -954,6 +992,8 @@ so that the destination matrix is reallocated if needed. While ``m.copyTo(m);``
 
 When the operation mask is specified, and the ``Mat::create`` call shown above reallocated the matrix, the newly allocated matrix is initialized with all zeros before copying the data.
 
+.. _Mat::convertTo:
+
 Mat::convertTo
 ------------------
 Converts an array to another datatype with optional scaling.
@@ -1115,7 +1155,7 @@ Returns a zero array of the specified size and type.
     :param cols: Number of columns.
 
     :param size: Alternative to the matrix size specification ``Size(cols, rows)``  .   
-	
+    
     :param sizes: Array of integers specifying the array shape.
 
     :param type: Created matrix type.
@@ -1144,8 +1184,8 @@ Returns an array of all 1's of the specified size and type.
     :param cols: Number of columns.
 
     :param size: Alternative to the matrix size specification  ``Size(cols, rows)``  .   
-	
-	:param sizes: Array of integers specifying the array shape.
+    
+    :param sizes: Array of integers specifying the array shape.
 
     :param type: Created matrix type.
 
@@ -1170,7 +1210,7 @@ Returns an identity matrix of the specified size and type.
     :param cols: Number of columns.
 
     :param size: Alternative matrix size specification as  ``Size(cols, rows)`` .     
-	
+    
     :param type: Created matrix type.
 
 The method returns a Matlab-style identity matrix initializer, similarly to
@@ -1196,7 +1236,7 @@ Allocates new array data if needed.
     :param cols: New number of columns.
 
     :param size: Alternative new matrix size specification:  ``Size(cols, rows)``     
-	
+    
     :param sizes: Array of integers specifying a new array shape.
 
     :param type: New matrix type.
@@ -1206,7 +1246,7 @@ This is one of the key ``Mat`` methods. Most new-style OpenCV functions and meth
 #.
     If the current array shape and the type match the new ones, return immediately. Otherwise, de-reference the previous data by calling
     :ocv:func:`Mat::release`. 
-	
+    
 #.
     Initialize the new header.
 
@@ -1360,9 +1400,9 @@ Extracts a rectangular submatrix.
 
 
     :param rowRange: Start and end row of the extracted submatrix. The upper boundary is not included. To select all the rows, use ``Range::all()``.    
-	
+    
     :param colRange: Start and end column of the extracted submatrix. The upper boundary is not included. To select all the columns, use  ``Range::all()``.    
-	
+    
     :param roi: Extracted submatrix specified as a rectangle.
 
     :param ranges: Array of selected ranges along each array dimension.
@@ -1484,7 +1524,7 @@ Mat::elemSize
 -----------------
 Returns  the matrix element size in bytes.
 
-.. ocv:function:: size_t Mat::elemSize(void) const
+.. ocv:function:: size_t Mat::elemSize() const
 
 The method returns the matrix element size in bytes. For example, if the matrix type is ``CV_16SC3`` , the method returns ``3*sizeof(short)`` or 6.
 
@@ -1493,7 +1533,7 @@ Mat::elemSize1
 ------------------
 Returns the size of each matrix element channel in bytes.
 
-.. ocv:function:: size_t Mat::elemSize() const
+.. ocv:function:: size_t Mat::elemSize1() const
 
 The method returns the matrix element channel size in bytes, that is, it ignores the number of channels. For example, if the matrix type is ``CV_16SC3`` , the method returns ``sizeof(short)`` or 2.
 
@@ -1675,9 +1715,9 @@ Mat::end
 ------------
 Returns the matrix iterator and sets it to the after-last matrix element.
 
-.. ocv:function:: MatIterator_<_Tp> Mat::end()
+.. ocv:function:: template<typename _Tp> MatIterator_<_Tp> Mat::end()
 
-.. ocv:function:: MatConstIterator_<_Tp> Mat::end() const
+.. ocv:function:: template<typename _Tp> MatConstIterator_<_Tp> Mat::end() const
 
 The methods return the matrix read-only or read-write iterators, set to the point following the last matrix element.
 
diff --git a/modules/core/doc/clustering.rst b/modules/core/doc/clustering.rst
index e37036aae3..81bfb7abb6 100644
--- a/modules/core/doc/clustering.rst
+++ b/modules/core/doc/clustering.rst
@@ -58,14 +58,12 @@ partition
 -------------
 Splits an element set into equivalency classes.
 
-.. ocv:function:: template<typename _Tp, class _EqPredicate> int
-
-.. ocv:function:: partition( const vector<_Tp>& vec, vector<int>& labels, _EqPredicate predicate=_EqPredicate())
+.. ocv:function:: template<typename _Tp, class _EqPredicate> int partition( const vector<_Tp>& vec, vector<int>& labels, _EqPredicate predicate=_EqPredicate())
 
     :param vec: Set of elements stored as a vector.
 
     :param labels: Output vector of labels. It contains as many elements as  ``vec``. Each label  ``labels[i]``  is a 0-based cluster index of  ``vec[i]`` .   
-	
+    
     :param predicate: Equivalence predicate (pointer to a boolean function of two arguments or an instance of the class that has the method  ``bool operator()(const _Tp& a, const _Tp& b)`` ). The predicate returns ``true`` when the elements are certainly in the same class, and returns ``false`` if they may or may not be in the same class.
 
 The generic function ``partition`` implements an
@@ -76,4 +74,4 @@ http://en.wikipedia.org/wiki/Disjoint-set_data_structure
 . The function
 returns the number of equivalency classes.
 
-.. [Arthur2007] Arthur and S. Vassilvitskii “k-means++: the advantages of careful seeding”, Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007
+.. [Arthur2007] Arthur and S. Vassilvitskii. k-means++: the advantages of careful seeding, Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, 2007
diff --git a/modules/core/doc/drawing_functions.rst b/modules/core/doc/drawing_functions.rst
index 9985c0073a..26edd8cfe5 100644
--- a/modules/core/doc/drawing_functions.rst
+++ b/modules/core/doc/drawing_functions.rst
@@ -68,7 +68,7 @@ Clips the line against the image rectangle.
 
     :param imgSize: Image size. The image rectangle is  ``Rect(0, 0, imgSize.width, imgSize.height)`` .     
 
-    :param imgSize: Image rectangle.?? why do you list the same para twice??
+    :param imgRect: Image rectangle.
 
     :param pt1: First line point.
 
@@ -137,9 +137,9 @@ Approximates an elliptic arc with a polyline.
     :param center: Center of the arc.
 
     :param axes: Half-sizes of the arc. See the  :ocv:func:`ellipse`  for details.   
-	
+    
     :param angle: Rotation angle of the ellipse in degrees. See the  :ocv:func:`ellipse`  for details.   
-	
+    
     :param startAngle: Starting angle of the elliptic arc in degrees.
 
     :param endAngle: Ending angle of the elliptic arc in degrees.
@@ -315,6 +315,7 @@ The function initializes the font structure that can be passed to text rendering
 
 .. seealso:: :ocv:cfunc:`PutText`
 
+.. _Line: 
 
 line
 --------
diff --git a/modules/core/doc/dynamic_structures.rst b/modules/core/doc/dynamic_structures.rst
index a92f95e2a3..de4f19bab9 100644
--- a/modules/core/doc/dynamic_structures.rst
+++ b/modules/core/doc/dynamic_structures.rst
@@ -176,6 +176,8 @@ The structure ``CvGraphScanner`` is used for depth-first graph traversal. See di
 CvTreeNodeIterator
 ------------------
 
+.. ocv:struct:: CvTreeNodeIterator
+
 The structure ``CvTreeNodeIterator`` is used to traverse trees of sequences.
 
 ClearGraph
diff --git a/modules/core/doc/old_basic_structures.rst b/modules/core/doc/old_basic_structures.rst
index 4e0c189752..d0bc05fc79 100644
--- a/modules/core/doc/old_basic_structures.rst
+++ b/modules/core/doc/old_basic_structures.rst
@@ -544,13 +544,13 @@ Converts one array to another with optional linear transformation.
 .. ocv:pyoldfunction:: cv.ConvertScale(src, dst, scale=1.0, shift=0.0)-> None
 .. ocv:pyoldfunction:: cv.Convert(src, dst)-> None
 
-::
+    ::
     
-    #define cvCvtScale cvConvertScale
-    #define cvScale  cvConvertScale
-    #define cvConvert(src, dst )  cvConvertScale((src), (dst), 1, 0 )
+        #define cvCvtScale cvConvertScale
+        #define cvScale  cvConvertScale
+        #define cvConvert(src, dst )  cvConvertScale((src), (dst), 1, 0 )
 
-..
+    ..
     
     :param src: Source array 
     
@@ -1729,7 +1729,7 @@ For example, `NumPy <http://numpy.scipy.org/>`_ arrays support the array interfa
 
 .. code-block::python
     
-    >>> import cv, numpy
+    >>> import cv2.cv as cv, numpy
     >>> a = numpy.ones((480, 640))
     >>> mat = cv.fromarray(a)
     >>> print cv.GetDims(mat), cv.CV_MAT_CN(cv.GetElemType(mat))
diff --git a/modules/core/doc/operations_on_arrays.rst b/modules/core/doc/operations_on_arrays.rst
index b29ae60115..227ee810ca 100644
--- a/modules/core/doc/operations_on_arrays.rst
+++ b/modules/core/doc/operations_on_arrays.rst
@@ -1814,24 +1814,26 @@ mixChannels
 -----------
 Copies specified channels from input arrays to the specified channels of output arrays.
 
-.. ocv:function:: void mixChannels(const Mat* srcv, int nsrc, Mat* dstv, int ndst, const int* fromTo, size_t npairs)
+.. ocv:function:: void mixChannels(const Mat* src, int nsrc, Mat* dst, int ndst, const int* fromTo, size_t npairs)
 
-.. ocv:function:: void mixChannels(const vector<Mat>& srcv, vector<Mat>& dstv, const int* fromTo, int npairs)
+.. ocv:function:: void mixChannels(const vector<Mat>& src, vector<Mat>& dst, const int* fromTo, int npairs)
 
 .. ocv:pyfunction:: cv2.mixChannels(src, dst, fromTo) -> None
 
 .. ocv:cfunction:: void cvMixChannels(const CvArr** src, int srcCount, CvArr** dst, int dstCount, const int* fromTo, int pairCount)
 .. ocv:pyoldfunction:: cv.MixChannels(src, dst, fromTo) -> None
 
-    :param srcv: Input array or vector of matrices. All the matrices must have the same size and the same depth.
+    :param src: Input array or vector of matrices. All the matrices must have the same size and the same depth.
 
-    :param nsrc: Number of elements in  ``srcv`` .
+    :param nsrc: Number of matrices in  ``src`` .
     
-    :param dstv: Output array or vector of matrices. All the matrices  *must be allocated* . Their size and depth must be the same as in  ``srcv[0]`` .
+    :param dst: Output array or vector of matrices. All the matrices  *must be allocated* . Their size and depth must be the same as in  ``src[0]`` .
         
-    :param ndst: Number of elements in  ``dstv`` .
+    :param ndst: Number of matrices in  ``dst`` .
     
-    :param fromTo: Array of index pairs specifying which channels are copied and where. ``fromTo[k*2]``  is a 0-based index of the input channel in  ``srcv`` . ``fromTo[k*2+1]``  is an index of the output channel in  ``dstv`` . The continuous channel numbering is used: the first input image channels are indexed from  ``0``  to  ``srcv[0].channels()-1`` , the second input image channels are indexed from  ``srcv[0].channels()``  to ``srcv[0].channels() + srcv[1].channels()-1``,  and so on. The same scheme is used for the output image channels. As a special case, when  ``fromTo[k*2]``  is negative, the corresponding output channel is filled with zero ``npairs`` .
+    :param fromTo: Array of index pairs specifying which channels are copied and where. ``fromTo[k*2]``  is a 0-based index of the input channel in  ``src`` . ``fromTo[k*2+1]``  is an index of the output channel in  ``dst`` . The continuous channel numbering is used: the first input image channels are indexed from  ``0``  to  ``src[0].channels()-1`` , the second input image channels are indexed from  ``src[0].channels()``  to ``src[0].channels() + src[1].channels()-1``,  and so on. The same scheme is used for the output image channels. As a special case, when  ``fromTo[k*2]``  is negative, the corresponding output channel is filled with zero .
+    
+    :param npairs: Number of index pairs in ``fromTo``.
     
 The functions ``mixChannels`` provide an advanced mechanism for shuffling image channels.
     
@@ -2161,13 +2163,13 @@ PCA constructors
 
     :param data: Input samples stored as matrix rows or matrix columns.
 
-    :param mean: Optional mean value. If the matrix is empty ( ``Mat()`` ), the mean is computed from the data.
+    :param mean: Optional mean value. If the matrix is empty ( ``noArray()`` ), the mean is computed from the data.
 
     :param flags: Operation flags. Currently the parameter is only used to specify the data layout.
 
-        * **CV_PCA_DATA_AS_ROWS** indicates that the input samples are stored as matrix rows.
+        * **CV_PCA_DATA_AS_ROW** indicates that the input samples are stored as matrix rows.
 
-        * **CV_PCA_DATA_AS_COLS** indicates that the input samples are stored as matrix columns.
+        * **CV_PCA_DATA_AS_COL** indicates that the input samples are stored as matrix columns.
 
     :param maxComponents: Maximum number of components that PCA should retain. By default, all the components are retained.
 
@@ -2186,13 +2188,13 @@ Performs Principal Component Analysis of the supplied dataset.
 
     :param data: Input samples stored as the matrix rows or as the matrix columns.
 
-    :param mean: Optional mean value. If the matrix is empty ( ``Mat()`` ), the mean is computed from the data.
+    :param mean: Optional mean value. If the matrix is empty ( ``noArray()`` ), the mean is computed from the data.
 
     :param flags: Operation flags. Currently the parameter is only used to specify the data layout.
 
-        * **CV_PCA_DATA_AS_ROWS** indicates that the input samples are stored as matrix rows.
+        * **CV_PCA_DATA_AS_ROW** indicates that the input samples are stored as matrix rows.
 
-        * **CV_PCA_DATA_AS_COLS** indicates that the input samples are stored as matrix columns.
+        * **CV_PCA_DATA_AS_COL** indicates that the input samples are stored as matrix columns.
 
     :param maxComponents: Maximum number of components that PCA should retain. By default, all the components are retained.
 
@@ -2212,9 +2214,9 @@ Projects vector(s) to the principal component subspace.
 
 .. ocv:pyfunction:: cv2.PCAProject(vec, mean, eigenvectors[, result]) -> result
 
-    :param vec: Input vector(s). They must have the same dimensionality and the same layout as the input data used at PCA phase. That is, if  ``CV_PCA_DATA_AS_ROWS``  are specified, then  ``vec.cols==data.cols``  (vector dimensionality) and  ``vec.rows``  is the number of vectors to project. The same is true for the  ``CV_PCA_DATA_AS_COLS``  case.
+    :param vec: Input vector(s). They must have the same dimensionality and the same layout as the input data used at PCA phase. That is, if  ``CV_PCA_DATA_AS_ROW``  are specified, then  ``vec.cols==data.cols``  (vector dimensionality) and  ``vec.rows``  is the number of vectors to project. The same is true for the  ``CV_PCA_DATA_AS_COL``  case.
 
-    :param result: Output vectors. In case of  ``CV_PCA_DATA_AS_COLS``  , the output matrix has as many columns as the number of input vectors. This means that  ``result.cols==vec.cols``  and the number of rows match the number of principal components (for example,  ``maxComponents``  parameter passed to the constructor).
+    :param result: Output vectors. In case of  ``CV_PCA_DATA_AS_COL``  , the output matrix has as many columns as the number of input vectors. This means that  ``result.cols==vec.cols``  and the number of rows match the number of principal components (for example,  ``maxComponents``  parameter passed to the constructor).
 
 The methods project one or more vectors to the principal component subspace, where each vector projection is represented by coefficients in the principal component basis. The first form of the method returns the matrix that the second form writes to the result. So the first form can be used as a part of expression while the second form can be more efficient in a processing loop.
 
@@ -2398,7 +2400,7 @@ For some values of ``p`` , such as integer values, 0.5 and -0.5, specialized fas
 RNG
 ---
 
-.. ocv:class: RNG
+.. ocv:class:: RNG
 
 Random number generator. It encapsulates the state (currently, a 64-bit integer) and has methods to return scalar random values and to fill arrays with random values. Currently it supports uniform and Gaussian (normal) distributions. The generator uses Multiply-With-Carry algorithm, introduced by G. Marsaglia (
 http://en.wikipedia.org/wiki/Multiply-with-carry
diff --git a/modules/core/doc/utility_and_system_functions_and_macros.rst b/modules/core/doc/utility_and_system_functions_and_macros.rst
index 0612a14efe..1a19daef74 100644
--- a/modules/core/doc/utility_and_system_functions_and_macros.rst
+++ b/modules/core/doc/utility_and_system_functions_and_macros.rst
@@ -187,7 +187,7 @@ Signals an error and raises an exception.
     :param exc: Exception to throw.
 
     :param code: Error code. Normally, it is a negative value. The list of pre-defined error codes can be found in  ``cxerror.h`` .   
-	
+    
     :param msg: Text of the error message.
 
     :param args: ``printf`` -like formatted error message in parentheses.
@@ -268,8 +268,8 @@ The function deallocates the buffer allocated with :ocv:func:`fastMalloc` . If N
 
 
 format
-----------
-Returns a text string formatted using the ``printf`` -like expression.
+------
+Returns a text string formatted using the ``printf``\ -like expression.
 
 .. ocv:function:: string format( const char* fmt, ... )
 
@@ -280,6 +280,28 @@ The function acts like ``sprintf``  but forms and returns an STL string. It can
 
 
 
+checkHardwareSupport
+--------------------
+Returns true if the specified feature is supported by the host hardware.
+
+.. ocv:function:: bool checkHardwareSupport(int feature)
+.. ocv:cfunction:: int cvCheckHardwareSupport(int feature)
+.. ocv:pyfunction:: checkHardwareSupport(feature) -> Bool
+
+    :param feature: The feature of interest, one of:
+    
+                        * ``CV_CPU_MMX`` - MMX
+                        * ``CV_CPU_SSE`` - SSE
+                        * ``CV_CPU_SSE2`` - SSE 2
+                        * ``CV_CPU_SSE3`` - SSE 3
+                        * ``CV_CPU_SSSE3`` - SSSE 3
+                        * ``CV_CPU_SSE4_1`` - SSE 4.1
+                        * ``CV_CPU_SSE4_2`` - SSE 4.2
+                        * ``CV_CPU_POPCNT`` - POPCOUNT
+                        * ``CV_CPU_AVX`` - AVX
+
+The function returns true if the host hardware supports the specified feature. When user calls ``setUseOptimized(false)``, the subsequent calls to ``checkHardwareSupport()`` will return false until ``setUseOptimized(true)`` is called. This way user can dynamically switch on and off the optimized code in OpenCV.
+
 getNumThreads
 -----------------
 Returns the number of threads used by OpenCV.
@@ -289,8 +311,8 @@ Returns the number of threads used by OpenCV.
 The function returns the number of threads that is used by OpenCV.
 
 .. seealso::
-:ocv:func:`setNumThreads`,
-:ocv:func:`getThreadNum` 
+   :ocv:func:`setNumThreads`,
+   :ocv:func:`getThreadNum` 
 
 
 
@@ -303,8 +325,8 @@ Returns the index of the currently executed thread.
 The function returns a 0-based index of the currently executed thread. The function is only valid inside a parallel OpenMP region. When OpenCV is built without OpenMP support, the function always returns 0.
 
 .. seealso::
-:ocv:func:`setNumThreads`,
-:ocv:func:`getNumThreads` .
+   :ocv:func:`setNumThreads`,
+   :ocv:func:`getNumThreads` .
 
 
 
@@ -388,8 +410,8 @@ Sets the number of threads used by OpenCV.
 The function sets the number of threads used by OpenCV in parallel OpenMP regions. If ``nthreads=0`` , the function uses the default number of threads that is usually equal to the number of the processing cores.
 
 .. seealso::
-:ocv:func:`getNumThreads`,
-:ocv:func:`getThreadNum` 
+   :ocv:func:`getNumThreads`,
+   :ocv:func:`getThreadNum` 
 
 
 
diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp
index dc75f4d514..9e1d8556dd 100644
--- a/modules/core/include/opencv2/core/core.hpp
+++ b/modules/core/include/opencv2/core/core.hpp
@@ -216,7 +216,7 @@ CV_EXPORTS int getThreadNum();
   before and after the function call. The granularity of ticks depends on the hardware and OS used. Use
   cv::getTickFrequency() to convert ticks to seconds.
 */
-CV_EXPORTS int64 getTickCount();
+CV_EXPORTS_W int64 getTickCount();
 
 /*!
   Returns the number of ticks per seconds.
@@ -240,7 +240,7 @@ CV_EXPORTS_W double getTickFrequency();
   one can accurately measure the execution time of very small code fragments,
   for which cv::getTickCount() granularity is not enough.
 */
-CV_EXPORTS int64 getCPUTickCount();
+CV_EXPORTS_W int64 getCPUTickCount();
 
 /*!
   Returns SSE etc. support status
@@ -263,6 +263,9 @@ CV_EXPORTS int64 getCPUTickCount();
 */
 CV_EXPORTS_W bool checkHardwareSupport(int feature);
 
+//! returns the number of CPUs (including hyper-threading)
+CV_EXPORTS_W int getNumberOfCPUs();
+    
 /*!
   Allocates memory buffer
   
@@ -589,6 +592,8 @@ public:
     explicit Vec(const _Tp* values);
 
     Vec(const Vec<_Tp, cn>& v);
+    Vec<_Tp, cn>& operator =(const Matx<_Tp, cn, 1>& m);
+    
     static Vec all(_Tp alpha);
 
     //! per-element multiplication
@@ -610,6 +615,10 @@ public:
     _Tp& operator[](int i);
     const _Tp& operator ()(int i) const;
     _Tp& operator ()(int i);
+    
+    Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);
+    Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);
+    template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);
 };
 
 
@@ -1267,6 +1276,7 @@ public:
     template<typename _Tp> _InputArray(const vector<vector<_Tp> >& vec);
     _InputArray(const vector<Mat>& vec);
     template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
+    _InputArray(const Scalar& s);
     _InputArray(const double& val);
     virtual Mat getMat(int i=-1) const;
     virtual void getMatVector(vector<Mat>& mv) const;
@@ -1327,6 +1337,7 @@ typedef InputArray InputArrayOfArrays;
 typedef const _OutputArray& OutputArray;
 typedef OutputArray OutputArrayOfArrays;
 typedef OutputArray InputOutputArray;
+typedef OutputArray InputOutputArrayOfArrays;
 
 CV_EXPORTS OutputArray noArray();
 
@@ -2031,13 +2042,15 @@ CV_EXPORTS_W void merge(const vector<Mat>& mv, OutputArray dst);
 //! copies each plane of a multi-channel array to a dedicated array
 CV_EXPORTS void split(const Mat& src, Mat* mvbegin);
 //! copies each plane of a multi-channel array to a dedicated array
-CV_EXPORTS_W void split(const Mat& m, vector<Mat>& mv);
+CV_EXPORTS_W void split(const Mat& m, CV_OUT vector<Mat>& mv);
     
 //! copies selected channels from the input arrays to the selected channels of the output arrays
 CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts,
                             const int* fromTo, size_t npairs);
 CV_EXPORTS void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
                             const int* fromTo, size_t npairs);
+CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputArrayOfArrays dst,
+                              const vector<int>& fromTo);
 
 //! extracts a single channel from src (coi is 0-based index)
 CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi);
@@ -2147,6 +2160,15 @@ CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
 //! solves linear system or a least-square problem
 CV_EXPORTS_W bool solve(InputArray src1, InputArray src2,
                         OutputArray dst, int flags=DECOMP_LU);
+
+enum
+{
+	SORT_EVERY_ROW=0,
+	SORT_EVERY_COLUMN=1,
+	SORT_ASCENDING=0,
+	SORT_DESCENDING=16
+};
+
 //! sorts independently each matrix row or each matrix column
 CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags);
 //! sorts independently each matrix row or each matrix column
@@ -2162,6 +2184,19 @@ CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1,
 CV_EXPORTS bool eigen(InputArray src, OutputArray eigenvalues,
                       OutputArray eigenvectors,
                       int lowindex=-1, int highindex=-1);
+CV_EXPORTS_W bool eigen(InputArray src, bool computeEigenvectors,
+                        OutputArray eigenvalues, OutputArray eigenvectors);
+
+enum
+{
+	COVAR_SCRAMBLED=0,
+	COVAR_NORMAL=1,
+	COVAR_USE_AVG=2,
+	COVAR_SCALE=4,
+	COVAR_ROWS=8,
+	COVAR_COLS=16
+};
+
 //! computes covariation matrix of a set of samples
 CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean,
                                  int flags, int ctype=CV_64F);
@@ -2246,6 +2281,16 @@ public:
     Mat mean; //!< mean value subtracted before the projection and added after the back projection
 };
 
+CV_EXPORTS_W void PCACompute(InputArray data, CV_OUT InputOutputArray mean,
+                             OutputArray eigenvectors, int maxComponents=0);
+    
+CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean,
+                             InputArray eigenvectors, OutputArray result);
+
+CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean,
+                                 InputArray eigenvectors, OutputArray result);
+
+
 /*!
     Singular Value Decomposition class
  
@@ -2295,6 +2340,14 @@ public:
     Mat u, w, vt;
 };
 
+//! computes SVD of src
+CV_EXPORTS_W void SVDecomp( InputArray src, CV_OUT OutputArray w,
+    CV_OUT OutputArray u, CV_OUT OutputArray vt, int flags=0 );
+
+//! performs back substitution for the previously computed SVD
+CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt,
+                               InputArray rhs, CV_OUT OutputArray dst );
+
 //! computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix
 CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar);
 //! a synonym for Mahalanobis
@@ -2342,6 +2395,7 @@ CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev
 
 //! shuffles the input array elements
 CV_EXPORTS void randShuffle(InputOutputArray dst, double iterFactor=1., RNG* rng=0);
+CV_EXPORTS_AS(randShuffle) void randShuffle_(InputOutputArray dst, double iterFactor=1.);
 
 //! draws the line segment (pt1, pt2) in the image
 CV_EXPORTS_W void line(Mat& img, Point pt1, Point pt2, const Scalar& color,
@@ -2376,6 +2430,9 @@ CV_EXPORTS_W void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
 CV_EXPORTS void fillConvexPoly(Mat& img, const Point* pts, int npts,
                                const Scalar& color, int lineType=8,
                                int shift=0);
+CV_EXPORTS_W void fillConvexPoly(InputOutputArray img, InputArray points,
+                                 const Scalar& color, int lineType=8,
+                                 int shift=0);
 
 //! fills an area bounded by one or more polygons
 CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
@@ -2383,16 +2440,24 @@ CV_EXPORTS void fillPoly(Mat& img, const Point** pts,
                          const Scalar& color, int lineType=8, int shift=0,
                          Point offset=Point() );
 
+CV_EXPORTS_W void fillPoly(InputOutputArray img, InputArrayOfArrays pts,
+                           const Scalar& color, int lineType=8, int shift=0,
+                           Point offset=Point() );
+
 //! draws one or more polygonal curves
 CV_EXPORTS void polylines(Mat& img, const Point** pts, const int* npts,
                           int ncontours, bool isClosed, const Scalar& color,
                           int thickness=1, int lineType=8, int shift=0 );
 
+CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
+                            bool isClosed, const Scalar& color,
+                            int thickness=1, int lineType=8, int shift=0 );
+
 //! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
 CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
 
 //! clips the line segment by the rectangle imgRect
-CV_EXPORTS_W bool clipLine(Rect imgRect, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);
+CV_EXPORTS_W bool clipLine(Rect imgRect, CV_OUT CV_IN_OUT Point& pt1, CV_OUT CV_IN_OUT Point& pt2);
 
 /*!
    Line iterator class
@@ -4167,78 +4232,108 @@ protected:
 #endif
 
 /*!
- Command Line Parser
-
- The class is used for reading command arguments.
- Supports the following syntax:
-   //-k=10 --key --db=-10.11 -key1 argument --inputFile=lena.jpg
-   CommandLineParser parser(argc, argv);
-   int k = parser.get<int>("k", -1);        //these methods also work
-   double db = parser.get<double>("db");    //with <float> and <unsigned int> type
-   bool key = parser.get<bool>("key"); <The method return 'true', if 'key' was defined in command line
-           "                           and it will return 'false' otherwise.>
-   bool key1 = parser.get<bool>("key1"); The method return 'true', if 'key' was defined in command line
-           "                             and it will return 'false' otherwise.>
-   string argument = parser.get<string>("0"); <If you need to take argument. It's the first parameter without '-' or '--' increment
-                            and without value. It has index 0. The second parameter of this type will have index 1>
-                            It also works with 'int', 'unsigned int', 'double' and 'float' types.
-   string inputFile = parser.get<string>("inputFile");
+"\nThe CommandLineParser class is designed for command line arguments parsing\n"
+           "Keys map: \n"
+           "Before you start to work with CommandLineParser you have to create a map for keys.\n"
+           "    It will look like this\n"
+           "    const char* keys =\n"
+           "    {\n"
+           "        {    s|  string|  123asd |string parameter}\n"
+           "        {    d|  digit |  100    |digit parameter }\n"
+           "        {    c|noCamera|false    |without camera  }\n"
+           "        {    1|        |some text|help            }\n"
+           "        {    2|        |333      |another help    }\n"
+           "    };\n"
+           "Usage syntax: \n"
+           "    \"{\" - start of parameter string.\n"
+           "    \"}\" - end of parameter string\n"
+           "    \"|\" - separator between short name, full name, default value and help\n"
+           "Supported syntax: \n"
+           "    --key1=arg1  <If a key with '--' must has an argument\n"
+           "                  you have to assign it through '=' sign.> \n"
+           "<If the key with '--' doesn't have any argument, it means that it is a bool key>\n"
+           "    -key2=arg2   <If a key with '-' must has an argument \n"
+           "                  you have to assign it through '=' sign.> \n"
+           "If the key with '-' doesn't have any argument, it means that it is a bool key\n"
+           "    key3                 <This key can't has any parameter> \n"
+           "Usage: \n"
+           "      Imagine that the input parameters are next:\n"
+           "                -s=string_value --digit=250 --noCamera lena.jpg 10000\n"
+           "    CommandLineParser parser(argc, argv, keys) - create a parser object\n"
+           "    parser.get<string>(\"s\" or \"string\") will return you first parameter value\n"
+           "    parser.get<string>(\"s\", false or \"string\", false) will return you first parameter value\n"
+           "                                                                without spaces in end and begin\n"
+           "    parser.get<int>(\"d\" or \"digit\") will return you second parameter value.\n"
+           "                    It also works with 'unsigned int', 'double', and 'float' types>\n"
+           "    parser.get<bool>(\"c\" or \"noCamera\") will return you true .\n"
+           "                                If you enter this key in commandline>\n"
+           "                                It return you false otherwise.\n"
+           "    parser.get<string>(\"1\") will return you the first argument without parameter (lena.jpg) \n"
+           "    parser.get<int>(\"2\") will return you the second argument without parameter (10000)\n"
+           "                          It also works with 'unsigned int', 'double', and 'float' types \n"
 */
 class CV_EXPORTS CommandLineParser
 {
     public:
 
-        //! the default constructor
-        CommandLineParser(int argc, const char* argv[]);
+    //! the default constructor
+      CommandLineParser(int argc, const char* argv[], const char* key_map);
 
-        //! get parameter, if parameter is not given get default parameter
-        template<typename _Tp>
-        _Tp get(const std::string& name, const _Tp& default_value = _Tp())
+    //! get parameter, you can choose: delete spaces in end and begin or not
+    template<typename _Tp>
+    _Tp get(const std::string& name, bool space_delete=true)
+    {
+        if (!has(name))
         {
-            std::string str = getString(name);
-            if (!has(name))
-                return default_value;
-            return analyzeValue<_Tp>(str);
+            return _Tp();
         }
+        std::string str = getString(name);
+        return analizeValue<_Tp>(str, space_delete);
+    }
+
+    //! print short name, full name, current value and help for all params
+    void printParams();
 
     protected:
-        std::map<std::string, std::string > data;
-        std::string getString(const std::string& name) const;
+    std::map<std::string, std::vector<std::string> > data;
+    std::string getString(const std::string& name);
 
-        bool has(const std::string& keys) const;
+    bool has(const std::string& keys);
 
-        template<typename _Tp>
-        static _Tp getData(const std::string& str)
-        {
-            _Tp res;
-            std::stringstream s1(str);
-            s1 >> res;
-            return res;
-        }
+    template<typename _Tp>
+    _Tp analizeValue(const std::string& str, bool space_delete=false);
 
-        template<typename _Tp>
-        _Tp fromStringNumber(const std::string& str);//the default conversion function for numbers
+    template<typename _Tp>
+    static _Tp getData(const std::string& str)
+    {
+        _Tp res;
+        std::stringstream s1(str);
+        s1 >> res;
+        return res;
+    }
+
+    template<typename _Tp>
+     _Tp fromStringNumber(const std::string& str);//the default conversion function for numbers
 
-        template<typename _Tp>
-        _Tp analyzeValue(const std::string& str);
     };
-    template<> CV_EXPORTS
-    bool CommandLineParser::get<bool>(const std::string& name, const bool& default_value);
 
-    template<> CV_EXPORTS
-    std::string CommandLineParser::analyzeValue<std::string>(const std::string& str);
+template<> CV_EXPORTS
+bool CommandLineParser::get<bool>(const std::string& name, bool space_delete);
 
-    template<> CV_EXPORTS
-    int CommandLineParser::analyzeValue<int>(const std::string& str);
+template<> CV_EXPORTS
+std::string CommandLineParser::analizeValue<std::string>(const std::string& str, bool space_delete);
 
-    template<> CV_EXPORTS
-    unsigned CommandLineParser::analyzeValue<unsigned int>(const std::string& str);
+template<> CV_EXPORTS
+int CommandLineParser::analizeValue<int>(const std::string& str, bool space_delete);
 
-    template<> CV_EXPORTS
-    float CommandLineParser::analyzeValue<float>(const std::string& str);
+template<> CV_EXPORTS
+unsigned CommandLineParser::analizeValue<unsigned int>(const std::string& str, bool space_delete);
 
-    template<> CV_EXPORTS
-    double CommandLineParser::analyzeValue<double>(const std::string& str);
+template<> CV_EXPORTS
+float CommandLineParser::analizeValue<float>(const std::string& str, bool space_delete);
+
+template<> CV_EXPORTS
+double CommandLineParser::analizeValue<double>(const std::string& str, bool space_delete);
 
 }
 
diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp
index a69673820f..6f444e4ed2 100644
--- a/modules/core/include/opencv2/core/mat.hpp
+++ b/modules/core/include/opencv2/core/mat.hpp
@@ -338,6 +338,7 @@ inline Mat Mat::colRange(const Range& r) const
 
 inline Mat Mat::diag(const Mat& d)
 {
+    CV_Assert( d.cols == 1 );
     Mat m(d.rows, d.rows, d.type(), Scalar(0)), md = m.diag();
     d.copyTo(md);
     return m;
@@ -675,7 +676,12 @@ template<typename _Tp, int m, int n> inline Mat::operator Matx<_Tp, m, n>() cons
 
 template<typename _Tp> inline void Mat::push_back(const _Tp& elem)
 {
-    CV_Assert(DataType<_Tp>::type == type() && cols == 1
+    if( !data )
+	{
+		*this = Mat(1, 1, DataType<_Tp>::type, (void*)&elem).clone();
+		return;
+	}
+	CV_Assert(DataType<_Tp>::type == type() && cols == 1
               /* && dims == 2 (cols == 1 implies dims == 2) */);
     uchar* tmp = dataend + step[0];
     if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
@@ -1098,18 +1104,21 @@ process( const Mat_<T1>& m1, const Mat_<T2>& m2, Mat_<T3>& m3, Op op )
     
 /////////////////////////////// Input/Output Arrays /////////////////////////////////
     
-template<typename _Tp> _InputArray::_InputArray(const vector<_Tp>& vec)
+template<typename _Tp> inline _InputArray::_InputArray(const vector<_Tp>& vec)
     : flags(STD_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
 
-template<typename _Tp> _InputArray::_InputArray(const vector<vector<_Tp> >& vec)
+template<typename _Tp> inline _InputArray::_InputArray(const vector<vector<_Tp> >& vec)
     : flags(STD_VECTOR_VECTOR + DataType<_Tp>::type), obj((void*)&vec) {}
 
-template<typename _Tp, int m, int n> _InputArray::_InputArray(const Matx<_Tp, m, n>& mtx)
+template<typename _Tp, int m, int n> inline _InputArray::_InputArray(const Matx<_Tp, m, n>& mtx)
     : flags(MATX + DataType<_Tp>::type), obj((void*)&mtx), sz(n, m) {}
 
-template<typename _Tp> _OutputArray::_OutputArray(vector<_Tp>& vec) : _InputArray(vec) {}
-template<typename _Tp> _OutputArray::_OutputArray(vector<vector<_Tp> >& vec) : _InputArray(vec) {}
-template<typename _Tp, int m, int n> _OutputArray::_OutputArray(Matx<_Tp, m, n>& mtx) : _InputArray(mtx) {}
+inline _InputArray::_InputArray(const Scalar& s)
+    : flags(MATX + CV_64F), obj((void*)&s), sz(1, 4) {} 
+    
+template<typename _Tp> inline _OutputArray::_OutputArray(vector<_Tp>& vec) : _InputArray(vec) {}
+template<typename _Tp> inline _OutputArray::_OutputArray(vector<vector<_Tp> >& vec) : _InputArray(vec) {}
+template<typename _Tp, int m, int n> inline _OutputArray::_OutputArray(Matx<_Tp, m, n>& mtx) : _InputArray(mtx) {}
     
 //////////////////////////////////// Matrix Expressions /////////////////////////////////////////
 
@@ -1303,6 +1312,37 @@ template<typename _Tp> static inline MatExpr max(double s, const Mat_<_Tp>& a)
 {
     return cv::max((const Mat&)a, s);
 }        
+
+template<typename _Tp> static inline void min(const Mat_<_Tp>& a, const Mat_<_Tp>& b, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, (const Mat&)b, (Mat&)c);
+}
+
+template<typename _Tp> static inline void min(const Mat_<_Tp>& a, double s, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, s, (Mat&)c);
+}
+
+template<typename _Tp> static inline void min(double s, const Mat_<_Tp>& a, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, s, (Mat&)c);
+}
+
+template<typename _Tp> static inline void max(const Mat_<_Tp>& a, const Mat_<_Tp>& b, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, (const Mat&)b, (Mat&)c);
+}
+
+template<typename _Tp> static inline void max(const Mat_<_Tp>& a, double s, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, s, (Mat&)c);
+}
+
+template<typename _Tp> static inline void max(double s, const Mat_<_Tp>& a, Mat_<_Tp>& c)
+{
+    cv::min((const Mat&)a, s, (Mat&)c);
+}
+
     
 CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
 CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp
index 60b4926c48..ee37b706da 100644
--- a/modules/core/include/opencv2/core/operations.hpp
+++ b/modules/core/include/opencv2/core/operations.hpp
@@ -625,14 +625,14 @@ Matx<_Tp, m, n> operator * (const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b)
 template<typename _Tp> static inline
 Point_<_Tp> operator * (const Matx<_Tp, 2, 2>& a, const Point_<_Tp>& b)
 {
-    return Point_<_Tp>(a*Vec<_Tp,2>(b));
+    return Point_<_Tp>(a*Vec<_Tp,2>(b.x,b.y));
 }
 
     
 template<typename _Tp> static inline
 Point3_<_Tp> operator * (const Matx<_Tp, 3, 3>& a, const Point3_<_Tp>& b)
 {
-    return Point3_<_Tp>(a*Vec<_Tp,3>(b));
+    return Point3_<_Tp>(a*Vec<_Tp,3>(b.x,b.y,b.z));
 }    
 
 
@@ -653,7 +653,7 @@ Matx<_Tp, 4, 1> operator * (const Matx<_Tp, 4, 4>& a, const Point3_<_Tp>& b)
 template<typename _Tp> static inline
 Scalar operator * (const Matx<_Tp, 4, 4>& a, const Scalar& b)
 {
-    return Scalar(a*Matx<_Tp, 4, 1>(b));
+    return Scalar(a*Matx<_Tp, 4, 1>(b[0],b[1],b[2],b[3]));
 }    
     
 
@@ -1017,10 +1017,33 @@ template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(const _Tp* values)
 {}
         
 
-template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& v)
-    : Matx<_Tp, cn, 1>(v.val)
+template<typename _Tp, int cn> inline Vec<_Tp, cn>::Vec(const Vec<_Tp, cn>& m)
+    : Matx<_Tp, cn, 1>(m.val)
 {}
 
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp op)
+: Matx<_Tp, cn, 1>(a, b, op)
+{}
+
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp op)
+: Matx<_Tp, cn, 1>(a, b, op)
+{}
+
+template<typename _Tp, int cn> template<typename _T2> inline
+Vec<_Tp, cn>::Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp op)
+: Matx<_Tp, cn, 1>(a, alpha, op)
+{}    
+    
+template<typename _Tp, int cn> inline
+Vec<_Tp, cn>& Vec<_Tp, cn>::operator = (const Matx<_Tp, cn, 1>& m)
+{
+    for( int i = 0; i < cn; i++ )
+        this->val[i] = m.val[i];
+    return *this;
+}
+    
 template<typename _Tp, int cn> inline Vec<_Tp, cn> Vec<_Tp, cn>::all(_Tp alpha)
 {
     Vec v;
@@ -1101,100 +1124,75 @@ operator -= (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b)
 template<typename _Tp, int cn> static inline Vec<_Tp, cn>
 operator + (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
 {
-    Vec<_Tp, cn> c = a;
-    return c += b;
+    return Vec<_Tp, cn>(a, b, Matx_AddOp());
 }
 
 template<typename _Tp, int cn> static inline Vec<_Tp, cn>
 operator - (const Vec<_Tp, cn>& a, const Vec<_Tp, cn>& b)
 {
-    Vec<_Tp, cn> c = a;
-    return c -= b;
+    return Vec<_Tp, cn>(a, b, Matx_SubOp());
 }
 
 template<typename _Tp, int cn> static inline
-Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, _Tp alpha)
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, int alpha)
 {
     for( int i = 0; i < cn; i++ )
-        a[i] *= alpha;
+        a[i] = saturate_cast<_Tp>(a[i]*alpha);
     return a;
 }
 
-template<int cn> static inline
-Vec<float, cn>& operator *= (Vec<float, cn>& a, double alpha)
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, float alpha)
 {
     for( int i = 0; i < cn; i++ )
-        a[i] *= (float)alpha;
-    return a;
-}
-
-template<int cn> static inline
-Vec<float, cn>& operator *= (Vec<float, cn>& a, int alpha)
-{
-    for( int i = 0; i < cn; i++ )
-        a[i] *= (float)alpha;
+        a[i] = saturate_cast<_Tp>(a[i]*alpha);
     return a;
 }
     
-template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (const Vec<_Tp, cn>& a, _Tp alpha)
+template<typename _Tp, int cn> static inline
+Vec<_Tp, cn>& operator *= (Vec<_Tp, cn>& a, double alpha)
 {
-    Vec<_Tp, cn> c = a;
-    return c *= alpha;
+    for( int i = 0; i < cn; i++ )
+        a[i] = saturate_cast<_Tp>(a[i]*alpha);
+    return a;
+}
+    
+    
+template<typename _Tp, int cn> static inline Vec<_Tp, cn>
+operator * (const Vec<_Tp, cn>& a, int alpha)
+{
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
 }
 
 template<typename _Tp, int cn> static inline Vec<_Tp, cn>
-operator * (_Tp alpha, const Vec<_Tp, cn>& a)
+operator * (int alpha, const Vec<_Tp, cn>& a)
 {
-    Vec<_Tp, cn> c = a;
-    return c *= alpha;
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
 }
 
-template<int cn> static inline Vec<float, cn>
-operator * (double alpha, const Vec<float, cn>& a)
+template<typename _Tp, int cn> static inline Vec<_Tp, cn>
+operator * (const Vec<_Tp, cn>& a, float alpha)
 {
-    Vec<float, cn> c = a;
-    return c *= (float)alpha;
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
 }
 
-template<int cn> static inline Vec<float, cn>
-operator * (const Vec<float, cn>& a, double alpha)
+template<typename _Tp, int cn> static inline Vec<_Tp, cn>
+operator * (float alpha, const Vec<_Tp, cn>& a)
 {
-    Vec<float, cn> c = a;
-    return c *= (float)alpha;
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
 }
 
-template<int cn> static inline Vec<float, cn>
-operator * (int alpha, const Vec<float, cn>& a)
+template<typename _Tp, int cn> static inline Vec<_Tp, cn>
+operator * (const Vec<_Tp, cn>& a, double alpha)
 {
-    Vec<float, cn> c = a;
-    return c *= (float)alpha;
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
 }
 
-template<int cn> static inline Vec<float, cn>
-operator * (const Vec<float, cn>& a, int alpha)
+template<typename _Tp, int cn> static inline Vec<_Tp, cn>
+operator * (double alpha, const Vec<_Tp, cn>& a)
 {
-    Vec<float, cn> c = a;
-    return c *= (float)alpha;
-}
-    
-template<typename _Tp> static inline Vec<_Tp, 4>
-operator * (const Vec<_Tp, 4>& a, const Vec<_Tp, 4>& b)
-{
-    return Vec<_Tp, 4>(saturate_cast<_Tp>(a[0]*b[0] - a[1]*b[1] - a[2]*b[2] - a[3]*b[3]),
-                       saturate_cast<_Tp>(a[0]*b[1] + a[1]*b[0] + a[2]*b[3] - a[3]*b[2]),
-                       saturate_cast<_Tp>(a[0]*b[2] - a[1]*b[3] + a[2]*b[0] - a[3]*b[1]),
-                       saturate_cast<_Tp>(a[0]*b[3] + a[1]*b[2] - a[2]*b[1] - a[3]*b[0]));
-}
-
-    
-template<typename _Tp> static inline Vec<_Tp, 4>&
-operator *= (Vec<_Tp, 4>& a, const Vec<_Tp, 4>& b)
-{
-    a = a*b;
-    return a;
-}
-    
+    return Vec<_Tp, cn>(a, alpha, Matx_ScaleOp());
+}    
 
 template<typename _Tp, int cn> static inline Vec<_Tp, cn>
 operator - (const Vec<_Tp, cn>& a)
@@ -1203,7 +1201,7 @@ operator - (const Vec<_Tp, cn>& a)
     for( int i = 0; i < cn; i++ ) t.val[i] = saturate_cast<_Tp>(-a.val[i]);
     return t;
 }
-
+    
 template<> inline Vec<float, 3> Vec<float, 3>::cross(const Vec<float, 3>& v) const
 {
     return Vec<float,3>(val[1]*v.val[2] - val[2]*v.val[1],
@@ -2000,7 +1998,7 @@ static inline bool operator !(const Range& r)
 
 static inline Range operator & (const Range& r1, const Range& r2)
 {
-    Range r(std::max(r1.start, r2.start), std::min(r2.start, r2.end));
+    Range r(std::max(r1.start, r2.start), std::min(r1.end, r2.end));
     r.end = std::max(r.end, r.start);
     return r;
 }
@@ -2780,7 +2778,8 @@ public:
         size_t remaining = it->remaining, cn = DataType<_Tp>::channels;
         int _fmt = DataType<_Tp>::fmt;
         char fmt[] = { (char)((_fmt>>8)+'1'), (char)_fmt, '\0' };
-        count = std::min(count, remaining/cn);
+		size_t remaining1 = remaining/cn;
+		count = count < remaining1 ? count : remaining1;
         vec.resize(count);
         it->readRaw( string(fmt), (uchar*)&vec[0], count*sizeof(_Tp) );
     }
diff --git a/modules/core/include/opencv2/core/version.hpp b/modules/core/include/opencv2/core/version.hpp
index b29c445cb2..0cd25ca8b3 100644
--- a/modules/core/include/opencv2/core/version.hpp
+++ b/modules/core/include/opencv2/core/version.hpp
@@ -49,7 +49,7 @@
 
 #define CV_MAJOR_VERSION    2
 #define CV_MINOR_VERSION    3
-#define CV_SUBMINOR_VERSION 0
+#define CV_SUBMINOR_VERSION 1
 
 #define CVAUX_STR_EXP(__A)  #__A
 #define CVAUX_STR(__A)      CVAUX_STR_EXP(__A)
diff --git a/modules/core/src/arithm.cpp b/modules/core/src/arithm.cpp
index fc9f6685d3..5f6c04f1a8 100644
--- a/modules/core/src/arithm.cpp
+++ b/modules/core/src/arithm.cpp
@@ -68,7 +68,9 @@ struct NOP {};
 template<typename T, class Op, class Op8>
 void vBinOp8(const T* src1, size_t step1, const T* src2, size_t step2, T* dst, size_t step, Size sz)
 {
+#if CV_SSE2
     Op8 op8;
+#endif
     Op op;
 
     for( ; sz.height--; src1 += step1/sizeof(src1[0]),
@@ -117,7 +119,9 @@ template<typename T, class Op, class Op16>
 void vBinOp16(const T* src1, size_t step1, const T* src2, size_t step2,
               T* dst, size_t step, Size sz)
 {
+#if CV_SSE2
     Op16 op16;
+#endif
     Op op;
 
     for( ; sz.height--; src1 += step1/sizeof(src1[0]),
@@ -168,7 +172,9 @@ template<class Op, class Op32>
 void vBinOp32s(const int* src1, size_t step1, const int* src2, size_t step2,
                int* dst, size_t step, Size sz)
 {
+#if CV_SSE2
     Op32 op32;
+#endif
     Op op;
 
     for( ; sz.height--; src1 += step1/sizeof(src1[0]),
@@ -223,7 +229,9 @@ template<class Op, class Op32>
 void vBinOp32f(const float* src1, size_t step1, const float* src2, size_t step2,
                float* dst, size_t step, Size sz)
 {
+#if CV_SSE2
     Op32 op32;
+#endif
     Op op;
 
     for( ; sz.height--; src1 += step1/sizeof(src1[0]),
@@ -276,7 +284,9 @@ template<class Op, class Op64>
 void vBinOp64f(const double* src1, size_t step1, const double* src2, size_t step2,
                double* dst, size_t step, Size sz)
 {
+#if CV_SSE2
     Op64 op64;
+#endif
     Op op;
 
     for( ; sz.height--; src1 += step1/sizeof(src1[0]),
@@ -1064,7 +1074,7 @@ void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
         {
             for( size_t j = 0; j < total; j += blocksize )
             {
-                int bsz = (int)std::min(total - j, blocksize);
+                int bsz = (int)MIN(total - j, blocksize);
 
                 func( ptrs[0], 0, ptrs[1], 0, haveMask ? maskbuf : ptrs[2], 0, Size(bsz*c, 1), 0 );
                 if( haveMask )
@@ -1096,7 +1106,7 @@ void binary_op(InputArray _src1, InputArray _src2, OutputArray _dst,
         {
             for( size_t j = 0; j < total; j += blocksize )
             {
-                int bsz = (int)std::min(total - j, blocksize);
+                int bsz = (int)MIN(total - j, blocksize);
 
                 func( ptrs[0], 0, scbuf, 0, haveMask ? maskbuf : ptrs[1], 0, Size(bsz*c, 1), 0 );
                 if( haveMask )
@@ -1128,25 +1138,41 @@ static BinaryFunc minTab[] =
 
 void cv::bitwise_and(InputArray a, InputArray b, OutputArray c, InputArray mask)
 {
-    BinaryFunc f = and8u;
+    BinaryFunc f = 
+#ifdef HAVE_TEGRA_OPTIMIZATION  
+		(BinaryFunc)tegra::
+#endif
+		and8u;
     binary_op(a, b, c, mask, &f, true);
 }
 
 void cv::bitwise_or(InputArray a, InputArray b, OutputArray c, InputArray mask)
 {
-    BinaryFunc f = or8u;
+    BinaryFunc f = 
+#ifdef HAVE_TEGRA_OPTIMIZATION  
+		(BinaryFunc)tegra::
+#endif
+		or8u;
     binary_op(a, b, c, mask, &f, true);
 }
 
 void cv::bitwise_xor(InputArray a, InputArray b, OutputArray c, InputArray mask)
 {
-    BinaryFunc f = xor8u;
+    BinaryFunc f = 
+#ifdef HAVE_TEGRA_OPTIMIZATION  
+		(BinaryFunc)tegra::
+#endif
+		xor8u;
     binary_op(a, b, c, mask, &f, true);
 }
 
 void cv::bitwise_not(InputArray a, OutputArray c, InputArray mask)
 {
-    BinaryFunc f = not8u;
+    BinaryFunc f = 
+#ifdef HAVE_TEGRA_OPTIMIZATION  
+		(BinaryFunc)tegra::
+#endif
+		not8u;
     binary_op(a, a, c, mask, &f, true);
 }
 
@@ -1291,7 +1317,7 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
     uchar *buf, *maskbuf = 0, *buf1 = 0, *buf2 = 0, *wbuf = 0;
     size_t bufesz = (cvtsrc1 ? wsz : 0) + (cvtsrc2 || haveScalar ? wsz : 0) + (cvtdst ? wsz : 0) + (haveMask ? dsz : 0);
 
-    _dst.create(src1.dims, src1.size, src1.type());
+    _dst.create(src1.dims, src1.size, dtype);
     Mat dst = _dst.getMat();
     BinaryFunc func = tab[CV_MAT_DEPTH(wtype)];
 
@@ -1322,7 +1348,7 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
         {
             for( size_t j = 0; j < total; j += blocksize )
             {
-                int bsz = (int)std::min(total - j, blocksize);
+                int bsz = (int)MIN(total - j, blocksize);
                 Size bszn(bsz*cn, 1);
                 const uchar *sptr1 = ptrs[0], *sptr2 = ptrs[1];
                 uchar* dptr = ptrs[2];
@@ -1387,7 +1413,7 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
         {
             for( size_t j = 0; j < total; j += blocksize )
             {
-                int bsz = (int)std::min(total - j, blocksize);
+                int bsz = (int)MIN(total - j, blocksize);
                 Size bszn(bsz*cn, 1);
                 const uchar *sptr1 = ptrs[0];
                 const uchar* sptr2 = buf2;
@@ -1427,6 +1453,20 @@ void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
     }
 }
 
+#ifdef HAVE_TEGRA_OPTIMIZATION  
+static BinaryFunc addTab[] =
+{
+    (BinaryFunc)tegra::add8u, (BinaryFunc)add8s, (BinaryFunc)add16u, (BinaryFunc)add16s,
+    (BinaryFunc)add32s, (BinaryFunc)add32f, (BinaryFunc)add64f, 0
+};
+
+static BinaryFunc subTab[] =
+{
+    (BinaryFunc)tegra::sub8u, (BinaryFunc)sub8s, (BinaryFunc)sub16u, (BinaryFunc)sub16s,
+    (BinaryFunc)sub32s, (BinaryFunc)sub32f, (BinaryFunc)sub64f, 0
+};
+
+#else
 static BinaryFunc addTab[] =
 {
     (BinaryFunc)add8u, (BinaryFunc)add8s, (BinaryFunc)add16u, (BinaryFunc)add16s,
@@ -1438,6 +1478,7 @@ static BinaryFunc subTab[] =
     (BinaryFunc)sub8u, (BinaryFunc)sub8s, (BinaryFunc)sub16u, (BinaryFunc)sub16s,
     (BinaryFunc)sub32s, (BinaryFunc)sub32f, (BinaryFunc)sub64f, 0
 };
+#endif
 
 static BinaryFunc absdiffTab[] =
 {
@@ -2083,8 +2124,8 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
 
     if( kind1 == kind2 && src1.dims <= 2 && src2.dims <= 2 && src1.size() == src2.size() && src1.type() == src2.type() )
     {
-        CV_Assert(src1.channels() == 1);
-        _dst.create(src1.size(), CV_8UC1);
+        int cn = src1.channels();
+        _dst.create(src1.size(), CV_8UC(cn));
         Mat dst = _dst.getMat();
         Size sz = getContinuousSize(src1, src2, dst, src1.channels());
         cmpTab[src1.depth()](src1.data, src1.step, src2.data, src2.step, dst.data, dst.step, sz, &op);
@@ -2110,15 +2151,15 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
         haveScalar = true;
     }
 
+    
     int cn = src1.channels(), depth1 = src1.depth(), depth2 = src2.depth();
-    if( cn != 1 )
-        CV_Error( CV_StsUnsupportedFormat, "compare() can only process single-channel arrays" );
 
+    _dst.create(src1.dims, src1.size, CV_8UC(cn));
+    src1 = src1.reshape(1); src2 = src2.reshape(1);
+    Mat dst = _dst.getMat().reshape(1);
+    
     size_t esz = src1.elemSize();
     size_t blocksize0 = (size_t)(BLOCK_SIZE + esz-1)/esz;
-
-    _dst.create(src1.dims, src1.size, CV_8U);
-    Mat dst = _dst.getMat();
     BinaryFunc func = cmpTab[depth1];
 
     if( !haveScalar )
@@ -2181,7 +2222,7 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
         {
             for( size_t j = 0; j < total; j += blocksize )
             {
-                int bsz = (int)std::min(total - j, blocksize);
+                int bsz = (int)MIN(total - j, blocksize);
                 func( ptrs[0], 0, buf, 0, ptrs[1], 0, Size(bsz, 1), &op);
                 ptrs[0] += bsz*esz;
                 ptrs[1] += bsz;
@@ -2387,7 +2428,7 @@ void cv::inRange(InputArray _src, InputArray _lowerb,
     {
         for( size_t j = 0; j < total; j += blocksize )
         {
-            int bsz = (int)std::min(total - j, blocksize);
+            int bsz = (int)MIN(total - j, blocksize);
             size_t delta = bsz*esz;
             uchar *lptr = lbuf, *uptr = ubuf;
             if( !lbScalar )
diff --git a/modules/core/src/cmdparser.cpp b/modules/core/src/cmdparser.cpp
index 012041ceea..f67f624ea3 100644
--- a/modules/core/src/cmdparser.cpp
+++ b/modules/core/src/cmdparser.cpp
@@ -1,4 +1,5 @@
 #include "precomp.hpp"
+#include "iostream"
 
 using namespace std;
 using namespace cv;
@@ -6,27 +7,44 @@ using namespace cv;
 void helpParser()
 {
     printf("\nThe CommandLineParser class is designed for command line arguments parsing\n"
+           "Keys map: \n"
+           "Before you start to work with CommandLineParser you have to create a map for keys.\n"
+           "    It will look like this\n"
+           "    const char* keys =\n"
+           "    {\n"
+           "        {    s|  string|  123asd |string parameter}\n"
+           "        {    d|  digit |  100    |digit parameter }\n"
+           "        {    c|noCamera|false    |without camera  }\n"
+           "        {    1|        |some text|help            }\n"
+           "        {    2|        |333      |another help    }\n"
+           "    };\n"
+           "Usage syntax: \n"
+           "    \"{\" - start of parameter string.\n"
+           "    \"}\" - end of parameter string\n"
+           "    \"|\" - separator between short name, full name, default value and help\n"
            "Supported syntax: \n"
-           "    --key1=arg1 or --key3 <The keys with '--' can have argument.\n"
-                                     "If it has argument, you should assign it through '=' sign> \n"
-           "    -key2=arg2 or -key2  <The keys witn '-' can have argument \n"
-                                    "If it has argument, you should assign it through '=' sign> \n"
+           "    --key1=arg1  <If a key with '--' must has an argument\n"
+           "                  you have to assign it through '=' sign.> \n"
+           "<If the key with '--' doesn't have any argument, it means that it is a bool key>\n"
+           "    -key2=arg2   <If a key with '-' must has an argument \n"
+           "                  you have to assign it through '=' sign.> \n"
+           "If the key with '-' doesn't have any argument, it means that it is a bool key\n"
            "    key3                 <This key can't has any parameter> \n"
            "Usage: \n"
            "      Imagine that the input parameters are next:\n"
-           "                -k=10 --key --db=-10.11 -key1 argument --inputFile=lena.jpg\n"
-           "parser.get<int>(\"k\")<If you need to take k value.\n"
-           "                    It also works with 'unsigned int', 'double', 'float' and 'string' types>\n"
-           "parser.get<double>(\"db\", 99.99)<If you need to take db value.\n"
-           "                                If its value is empty, you will get default value 99.99>\n"
-           "                                It also works with 'int', 'unsigned int', 'float' and 'string' types\n"
-           "parser.get<bool>(\"key\")<The method return 'true', if 'key' was defined in command line\n"
-           "                          and it will return 'false' otherwise.>\n"
-           "parser.get<bool>(\"key1\")<The method return 'true', if 'key' was defined in command line\n"
-           "                          and it will return 'false' otherwise.>\n"
-           "parser.get<stirng>(\"0\")<If you need to take argument. It's the first parameter without '-' or '--' increment \n"
-           "                          and without value. It has index 0. The second parameter of this type will have index 1>\n"
-           "                          It also works with 'int', 'unsigned int', 'double' and 'float' types\n\n"
+           "                -s=string_value --digit=250 --noCamera lena.jpg 10000\n"
+           "    CommandLineParser parser(argc, argv, keys) - create a parser object\n"
+           "    parser.get<string>(\"s\" or \"string\") will return you first parameter value\n"
+           "    parser.get<string>(\"s\", false or \"string\", false) will return you first parameter value\n"
+           "                                                                without spaces in end and begin\n"
+           "    parser.get<int>(\"d\" or \"digit\") will return you second parameter value.\n"
+           "                    It also works with 'unsigned int', 'double', and 'float' types>\n"
+           "    parser.get<bool>(\"c\" or \"noCamera\") will return you true .\n"
+           "                                If you enter this key in commandline>\n"
+           "                                It return you false otherwise.\n"
+           "    parser.get<string>(\"1\") will return you the first argument without parameter (lena.jpg) \n"
+           "    parser.get<int>(\"2\") will return you the second argument without parameter (10000)\n"
+           "                          It also works with 'unsigned int', 'double', and 'float' types \n"
            );
 }
 
@@ -37,166 +55,179 @@ vector<string> split_string(const string& str, const string& delimiters)
     string::size_type pos     = str.find_first_of(delimiters, lastPos);
     while (string::npos != pos || string::npos != lastPos)
     {
+
         res.push_back(str.substr(lastPos, pos - lastPos));
         lastPos = str.find_first_not_of(delimiters, pos);
+        if (str[pos + 1] == '|' && str[pos] == '|')
+        {
+            res.push_back("");
+            if(str[pos + 2] == '|')
+                res.push_back("");
+        }
+        if (str[pos + 1] == '\0')
+            res.push_back("");
         pos = str.find_first_of(delimiters, lastPos);
     }
 
     return res;
 }
 
-CommandLineParser::CommandLineParser(int argc, const char* argv[])
+CommandLineParser::CommandLineParser(int argc, const char* argv[], const char* keys)
 {
-    std::string cur_name;
+
+    std::string keys_buffer;
+    std::string values_buffer;
     std::string buffer;
-    std::stringstream str_buff(std::stringstream::in | std::stringstream::out);
-    std::map<std::string, std::string >::iterator it;
-    int find_symbol;
-    int index = 0;
+    std::string curName;
+    std::vector<string> keysVector;
+    std::vector<string> paramVector;
+    std::map<std::string, std::vector<std::string> >::iterator it;
+    size_t flagPosition;
+    int currentIndex = 1;
+    bool isFound = false;
+    bool withNoKey = false;
+    bool hasValueThroughEq = false;
 
-
-    for(int i = 1; i < argc; i++)
+    keys_buffer = keys;
+    while (!keys_buffer.empty())
     {
 
-        if(!argv[i])
-            break;
-        cur_name = argv[i];
-        if((cur_name.find('-') == 0) && ((int)cur_name.find('=') != -1) &&
-           (cur_name.find('=') != (cur_name.length() - 1)))
-        {
-            while (cur_name.find('-') == 0)
-                cur_name.erase(0,1);
+        flagPosition = keys_buffer.find_first_of('}');
+        flagPosition++;
+        buffer = keys_buffer.substr(0, flagPosition);
+        keys_buffer.erase(0, flagPosition);
 
-            buffer = cur_name;
-            find_symbol = (int)cur_name.find('=');
-            cur_name.erase(find_symbol);
-            buffer.erase(0, find_symbol + 1);
-            if (data.find(cur_name) != data.end())
+        flagPosition = buffer.find('{');
+        if (flagPosition != buffer.npos)
+            buffer.erase(flagPosition, (flagPosition + 1));
+
+        flagPosition = buffer.find('}');
+        if (flagPosition != buffer.npos)
+            buffer.erase(flagPosition);
+
+        paramVector = split_string(buffer, "|");
+        buffer = paramVector[0];
+        if (atoi(buffer.c_str()) == 0)
+            buffer = buffer + '|' + paramVector[1];
+
+        paramVector.erase(paramVector.begin(), paramVector.begin() + 2);
+        data[buffer] = paramVector;
+    }
+
+    buffer.clear();
+    keys_buffer.clear();
+    paramVector.clear();
+    for (int i = 1; i < argc; i++)
+    {
+        if (!argv[i])
+            break;
+        curName = argv[i];
+        if (curName.find('-') == 0 && ((curName[1] < '0') || (curName[1] > '9')))
+        {
+            while (curName.find('-') == 0)
+                curName.erase(curName.begin(), (curName.begin() + 1));
+        }
+            else
+                withNoKey = true;
+        if (curName.find('=') != curName.npos)
+        {
+            hasValueThroughEq = true;
+            buffer = curName;
+            curName.erase(curName.find('='));
+            buffer.erase(0, (buffer.find('=') + 1));
+        }
+
+        for(it = data.begin(); it != data.end(); it++)
+        {
+            keys_buffer = it->first;
+            keysVector = split_string(keys_buffer, "| ");
+            if (keysVector.size() == 1)
+                keysVector.push_back("");
+            values_buffer = it->second[0];
+            if (((curName == keysVector[0]) || (curName == keysVector[1])) && hasValueThroughEq)
             {
-                printf("CommandLineParser constructor found dublicating parameters for name=%s\n"
-                       , cur_name.c_str());
-                printf("Constructor will not continue its work since this moment.\n"
-                       "Please enter parameters without dublicates\n");
-                helpParser();
-                data.clear();
+                it->second[0] = buffer;
+                isFound = true;
                 break;
             }
-                else
-                    data[cur_name] = buffer;
+
+            if (!hasValueThroughEq && (values_buffer.find("false") == values_buffer.npos) &&
+                ((curName == keysVector[0]) || (curName == keysVector[1])))
+
+            {
+                it->second[0] = argv[++i];
+                isFound = true;
+                break;
+            }
+
+            if (!hasValueThroughEq &&  (values_buffer.find("false") != values_buffer.npos)
+                && ((curName == keysVector[0]) || (curName == keysVector[1])))
+
+            {
+                it->second[0] = "true";
+                isFound = true;
+                break;
+            }
+
+            if (withNoKey)
+            {
+                std::string noKeyStr = it->first;
+                if(atoi(noKeyStr.c_str()) == currentIndex)
+                {
+                    it->second[0] = curName;
+                    currentIndex++;
+                    isFound = true;
+                    break;
+                }
+            }
         }
-            else if (cur_name.find('=') == 0)
-                {
-                    printf("The next key is wrong: key= %s\n", cur_name.c_str());
-                    printf("Constructor will not continue its work since this moment.\n"
-                           "Please enter parameters without any mistakes\n");
-                    helpParser();
-                    data.clear();
-                    break;
-                }
-            else if(((int)cur_name.find('-') == -1) && ((int)cur_name.find('=') != -1))
-                {
-                    printf("The next key must be defined with '--' or '-' increment: key= %s\n", cur_name.c_str());
-                    printf("Constructor will not continue its work since this moment.\n"
-                           "Please enter parameters without any mistakes\n");
-                    helpParser();
-                    data.clear();
-                    break;
-                }
-            else if (cur_name.find('=') == (cur_name.length() - 1))
-                {
-                    printf("The next key must have argument after '=': key= %s\n", cur_name.c_str());
-                    printf("Constructor will not continue its work since this moment.\n"
-                           "Please enter parameters without any mistakes\n");
-                    helpParser();
-                    data.clear();
-                    break;
-                }
-            else if ((cur_name.find('-') == 0) && ((cur_name[1] < '0') || (cur_name[1] > '9')) )
-                {
-                    while (cur_name.find('-') == 0)
-                    cur_name.erase(0,1);
-
-                    for(it = data.begin(); it != data.end(); it++)
-                    {
-                        if (it->first == cur_name)
-                        {
-                            printf("CommandLineParser constructor found dublicating parameters for name=%s\n"
-                                   , cur_name.c_str());
-                            printf("Constructor will not continue its work since this moment.\n"
-                                   "Please enter parameters without dublicates\n");
-                            helpParser();
-                            data.clear();
-                            break;
-                        }
-                    }
-                    data[cur_name] = "true";
-                }
-            else
-                {
-                    str_buff << index;
-                    for(it = data.begin(); it != data.end(); it++)
-                    {
-                        if (it->second == cur_name)
-                        {
-                            printf("CommandLineParser constructor found dublicating parameters for name=%s\n"
-                                   , cur_name.c_str());
-                            printf("Constructor will not continue its work since this moment.\n"
-                                   "Please enter parameters without dublicates\n");
-                            helpParser();
-                            data.clear();
-                            break;
-                        }
-                    }
-                    data[str_buff.str()] = cur_name;
-                    str_buff.seekp(0);
-                    index++;
-                }
 
+        withNoKey = false;
+        hasValueThroughEq = false;
+        if(!isFound)
+            printf("The current parameter is not defined: %s\n", curName.c_str());
+        isFound = false;
     }
+
+
 }
 
-bool CommandLineParser::has(const std::string& keys) const
+bool CommandLineParser::has(const std::string& keys)
 {
-    vector<string> names=split_string(keys, " |");
-    for(size_t j=0; j < names.size(); j++) {
-        if (data.find(names[j])!=data.end())
+    std::map<std::string, std::vector<std::string> >::iterator it;
+    std::vector<string> keysVector;
+    for(it = data.begin(); it != data.end(); it++)
+    {
+        keysVector = split_string(it->first, "| ");
+        if (keysVector.size() == 1)
+            keysVector.push_back("");
+        if ((keys == keysVector[0]) || (keys == keysVector[1]))
             return true;
     }
     return false;
 }
 
-std::string CommandLineParser::getString(const std::string& keys) const
+std::string CommandLineParser::getString(const std::string& keys)
 {
-    vector<string> names=split_string(keys, " |");
+    std::map<std::string, std::vector<std::string> >::iterator it;
+    std::vector<string> valueVector;
 
-    int found_index=-1;
-    for(size_t j=0; j < names.size(); j++) {
-        const string& cur_name=names[j];
-        bool is_cur_found=has(cur_name);
-
-        if (is_cur_found && (found_index >= 0)) {
-            string str_exception="dublicating parameters for "
-                "name='" + names[found_index] + "' and name='"+cur_name+"'";
-            CV_Error(CV_StsParseError, str_exception);
-        }
-
-        if (is_cur_found)
-            found_index=j;
+    for(it = data.begin(); it != data.end(); it++)
+    {
+        valueVector = split_string(it->first, "| ");
+        if (valueVector.size() == 1)
+            valueVector.push_back("");
+        if ((keys == valueVector[0]) || (keys == valueVector[1]))
+            return it->second[0];
     }
-
-    if (found_index<0)
-        return string();
-    return data.find(names[found_index])->second;
+    return string();
 }
 
 template<typename _Tp>
- _Tp CommandLineParser::fromStringNumber(const std::string& str) //the default conversion function for numbers
+ _Tp CommandLineParser::fromStringNumber(const std::string& str)//the default conversion function for numbers
 {
-    if (str.empty())
-        CV_Error(CV_StsParseError, "Empty string cannot be converted to a number");
-
     const char* c_str=str.c_str();
-    if((!isdigit(c_str[0]))
+    if ((!isdigit(c_str[0]))
         &&
         (
             (c_str[0]!='-') || (strlen(c_str) <= 1) || ( !isdigit(c_str[1]) )
@@ -204,71 +235,77 @@ template<typename _Tp>
     )
 
     {
-        CV_Error(CV_StsParseError, "The string '"+ str +"' cannot be converted to a number");
+        printf("This string cannot be converted to a number. Zero will be returned %s\n ", str.c_str());
+        return _Tp();
     }
 
     return  getData<_Tp>(str);
 }
 
-template<typename _Tp>
-static _Tp getData(const std::string& str)
-{
-    _Tp res;
-    std::stringstream s1(str);
-    s1 >> res;
-    return res;
-}
-
-template<typename _Tp>
-static _Tp fromStringNumber(const std::string& str)//the default conversion function for numbers
-{
-    
-    if (str.empty())
-        CV_Error(CV_StsParseError, "Empty string cannot be converted to a number");
-    
-    const char* c_str=str.c_str();
-    if( !isdigit(c_str[0]) &&
-       (c_str[0] != '-' || strlen(c_str) <= 1 || !isdigit(c_str[1]) ))
-        CV_Error(CV_StsParseError, "The string '"+ str +"' cannot be converted to a number");
-    
-    return  getData<_Tp>(str);
-}
+ void CommandLineParser::printParams()
+ {
+     std::map<std::string, std::vector<std::string> >::iterator it;
+     std::vector<string> keysVector;
+     for(it = data.begin(); it != data.end(); it++)
+     {
+         keysVector = split_string(it->first, "| ");
+         if (keysVector.size() == 1)
+             keysVector.push_back("");
+         printf("\t%s [%8s] (%12s - by default) - %s\n", keysVector[0].c_str(),
+                keysVector[1].c_str(), it->second[0].c_str(), it->second[1].c_str());
+     }
+ }
 
 template<>
-bool CommandLineParser::get<bool>(const std::string& name, const bool& /*default_value*/)
+bool CommandLineParser::get<bool>(const std::string& name, bool space_delete)
 {
-    if (!has(name))
+    std::string str_buf = getString(name);
+    if (space_delete)
+    {
+        while (str_buf.find_first_of(' ') == 0)
+            str_buf.erase(0, 1);
+        while (str_buf.find_last_of(' ') == (str_buf.length() - 1))
+            str_buf.erase(str_buf.end() - 1, str_buf.end());
+    }
+    if (str_buf == "false")
         return false;
     return true;
 }
-
 template<>
-std::string CommandLineParser::analyzeValue<std::string>(const std::string& str)
+std::string CommandLineParser::analizeValue<std::string>(const std::string& str, bool space_delete)
 {
+    if (space_delete)
+    {
+        std::string str_buf = str;
+        while (str_buf.find_first_of(' ') == 0)
+            str_buf.erase(0, 1);
+        while (str_buf.find_last_of('-') == (str.length() - 1))
+            str_buf.erase(str_buf.end() - 1, str_buf.end());
+        return str_buf;
+    }
     return str;
 }
 
 template<>
-int CommandLineParser::analyzeValue<int>(const std::string& str)
+int CommandLineParser::analizeValue<int>(const std::string& str, bool space_delete)
 {
     return fromStringNumber<int>(str);
 }
 
 template<>
-unsigned int CommandLineParser::analyzeValue<unsigned int>(const std::string& str)
+unsigned int CommandLineParser::analizeValue<unsigned int>(const std::string& str, bool space_delete)
 {
     return fromStringNumber<unsigned int>(str);
 }
 
 template<>
-float CommandLineParser::analyzeValue<float>(const std::string& str)
+float CommandLineParser::analizeValue<float>(const std::string& str, bool space_delete)
 {
     return fromStringNumber<float>(str);
 }
 
 template<>
-double CommandLineParser::analyzeValue<double>(const std::string& str)
+double CommandLineParser::analizeValue<double>(const std::string& str, bool space_delete)
 {
     return fromStringNumber<double>(str);
 }
-
diff --git a/modules/core/src/convert.cpp b/modules/core/src/convert.cpp
index 73b13ad717..c0a7c4930d 100644
--- a/modules/core/src/convert.cpp
+++ b/modules/core/src/convert.cpp
@@ -220,7 +220,7 @@ void cv::split(const Mat& src, Mat* mv)
     SplitFunc func = splitTab[depth];
     CV_Assert( func != 0 );
     
-    int esz = src.elemSize(), esz1 = src.elemSize1();
+    int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
     int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
     const Mat** arrays = (const Mat**)(uchar*)_buf;
@@ -305,7 +305,7 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
     }
         
     size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
-    int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
+    int blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
     AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
     const Mat** arrays = (const Mat**)(uchar*)_buf;
     uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
@@ -451,12 +451,12 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
                 if( i0 < src[j].channels() )
                     break;
             CV_Assert(j < nsrcs && src[j].depth() == depth);
-            tab[i*4] = j; tab[i*4+1] = i0*esz1;
+            tab[i*4] = (int)j; tab[i*4+1] = (int)(i0*esz1);
             sdelta[i] = src[j].channels();
         }
         else
         {
-            tab[i*4] = nsrcs + ndsts; tab[i*4+1] = 0;
+            tab[i*4] = (int)(nsrcs + ndsts); tab[i*4+1] = 0;
             sdelta[i] = 0;
         }
         
@@ -464,11 +464,11 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
             if( i1 < dst[j].channels() )
                 break;
         CV_Assert(i1 >= 0 && j < ndsts && dst[j].depth() == depth);
-        tab[i*4+2] = j + nsrcs; tab[i*4+3] = i1*esz1;
+        tab[i*4+2] = (int)(j + nsrcs); tab[i*4+3] = (int)(i1*esz1);
         ddelta[i] = dst[j].channels();
     }
 
-    NAryMatIterator it(arrays, ptrs, nsrcs + ndsts);
+    NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
     int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
     MixChannelsFunc func = mixchTab[depth];
     
@@ -503,6 +503,22 @@ void cv::mixChannels(const vector<Mat>& src, vector<Mat>& dst,
                 !dst.empty() ? &dst[0] : 0, dst.size(), fromTo, npairs);
 }
 
+void cv::mixChannels(InputArrayOfArrays src, InputArrayOfArrays dst,
+                     const vector<int>& fromTo)
+{
+    if(fromTo.empty())
+        return;
+    int i, nsrc = (int)src.total(), ndst = (int)dst.total();
+    CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0);
+    cv::AutoBuffer<Mat> _buf(nsrc + ndst);
+    Mat* buf = _buf;
+    for( i = 0; i < nsrc; i++ )
+        buf[i] = src.getMat(i);
+    for( i = 0; i < ndst; i++ )
+        buf[nsrc + i] = dst.getMat(i);
+    mixChannels(&buf[0], nsrc, &buf[nsrc], ndst, &fromTo[0], fromTo.size()/2);
+}
+
 void cv::extractChannel(InputArray _src, OutputArray _dst, int coi)
 {
     Mat src = _src.getMat();
diff --git a/modules/core/src/copy.cpp b/modules/core/src/copy.cpp
index 620154f733..43f601c367 100644
--- a/modules/core/src/copy.cpp
+++ b/modules/core/src/copy.cpp
@@ -207,9 +207,11 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
         return;
     }
     
-    CV_Assert( mask.type() == CV_8U );
+    int cn = channels(), mcn = mask.channels();
+    CV_Assert( mask.depth() == CV_8U && (mcn == 1 || mcn == cn) );
+    bool colorMask = mcn > 1;
     
-    size_t esz = elemSize();
+    size_t esz = colorMask ? elemSize1() : elemSize();
     BinaryFunc copymask = getCopyMaskFunc(esz);
     
     uchar* data0 = _dst.getMat().data;
@@ -221,7 +223,7 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
     
     if( dims <= 2 )
     {
-        Size sz = getContinuousSize(*this, dst, mask);
+        Size sz = getContinuousSize(*this, dst, mask, mcn);
         copymask(data, step, mask.data, mask.step, dst.data, dst.step, sz, &esz);
         return;
     }
@@ -229,7 +231,7 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
     const Mat* arrays[] = { this, &dst, &mask, 0 };
     uchar* ptrs[3];
     NAryMatIterator it(arrays, ptrs);
-    Size sz((int)it.size, 1);
+    Size sz((int)(it.size*mcn), 1);
     
     for( size_t i = 0; i < it.nplanes; i++, ++it )
         copymask(ptrs[0], 0, ptrs[2], 0, ptrs[1], 0, sz, &esz);
@@ -257,7 +259,7 @@ Mat& Mat::operator = (const Scalar& s)
             
             for( size_t j = 0; j < size; j += blockSize )
             {
-                size_t sz = std::min(blockSize, size - j);
+                size_t sz = MIN(blockSize, size - j);
                 memcpy( ptr + j, scalar, sz );
             }
         }
@@ -316,13 +318,13 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
 static void
 flipHoriz( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz )
 {
-    int i, j, limit = ((size.width + 1)/2)*esz;
+    int i, j, limit = (int)(((size.width + 1)/2)*esz);
     AutoBuffer<int> _tab(size.width*esz);
     int* tab = _tab;
     
     for( i = 0; i < size.width; i++ )
         for( size_t k = 0; k < esz; k++ )
-            tab[i*esz + k] = (size.width - i - 1)*esz + k;
+            tab[i*esz + k] = (int)((size.width - i - 1)*esz + k);
 
     for( ; size.height--; src += sstep, dst += dstep )
     {
diff --git a/modules/core/src/datastructs.cpp b/modules/core/src/datastructs.cpp
index 917c6ea7f1..59a482962d 100644
--- a/modules/core/src/datastructs.cpp
+++ b/modules/core/src/datastructs.cpp
@@ -3945,7 +3945,7 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
 
     if( _neighborsIdx.needed() )
     {
-        _neighborsIdx.create(idx.size(), 1, CV_32S, -1, true);
+        _neighborsIdx.create((int)idx.size(), 1, CV_32S, -1, true);
         Mat nidx = _neighborsIdx.getMat();
         Mat(nidx.size(), CV_32S, &idx[0]).copyTo(nidx);
     }
diff --git a/modules/core/src/drawing.cpp b/modules/core/src/drawing.cpp
index d8101fd8d0..f8e8a513bf 100644
--- a/modules/core/src/drawing.cpp
+++ b/modules/core/src/drawing.cpp
@@ -2012,6 +2012,63 @@ Size getTextSize( const string& text, int fontFace, double fontScale, int thickn
 
 }
 
+
+void cv::fillConvexPoly(InputOutputArray _img, InputArray _points,
+                        const Scalar& color, int lineType, int shift)
+{
+    Mat img = _img.getMat(), points = _points.getMat();
+    CV_Assert(points.checkVector(2, CV_32S) >= 0);
+    fillConvexPoly(img, (const Point*)points.data, points.rows*points.cols*points.channels()/2, color, lineType, shift);
+}
+
+
+void cv::fillPoly(InputOutputArray _img, InputArrayOfArrays pts,
+                  const Scalar& color, int lineType, int shift, Point offset)
+{
+    Mat img = _img.getMat();
+    int i, ncontours = (int)pts.total();
+    if( ncontours == 0 )
+        return;
+    AutoBuffer<Point*> _ptsptr(ncontours);
+    AutoBuffer<int> _npts(ncontours);
+    Point** ptsptr = _ptsptr;
+    int* npts = _npts;
+    
+    for( i = 0; i < ncontours; i++ )
+    {
+        Mat p = pts.getMat(i);
+        CV_Assert(p.checkVector(2, CV_32S) >= 0);
+        ptsptr[i] = (Point*)p.data;
+        npts[i] = p.rows*p.cols*p.channels()/2;
+    }
+    fillPoly(img, (const Point**)ptsptr, npts, (int)ncontours, color, lineType, shift, offset);
+}
+
+
+void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
+                   bool isClosed, const Scalar& color,
+                   int thickness, int lineType, int shift )
+{
+    Mat img = _img.getMat();
+    int i, ncontours = (int)pts.total();
+    if( ncontours == 0 )
+        return;
+    AutoBuffer<Point*> _ptsptr(ncontours);
+    AutoBuffer<int> _npts(ncontours);
+    Point** ptsptr = _ptsptr;
+    int* npts = _npts;
+    
+    for( i = 0; i < ncontours; i++ )
+    {
+        Mat p = pts.getMat(i);
+        CV_Assert(p.checkVector(2, CV_32S) >= 0);
+        ptsptr[i] = (Point*)p.data;
+        npts[i] = p.rows*p.cols*p.channels()/2;
+    }
+    polylines(img, (const Point**)ptsptr, npts, (int)ncontours, isClosed, color, thickness, lineType, shift);
+}
+
+
 static const int CodeDeltas[8][2] =
 { {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1} };
 
diff --git a/modules/core/src/lapack.cpp b/modules/core/src/lapack.cpp
index 03785f9ec6..c88125e4fb 100644
--- a/modules/core/src/lapack.cpp
+++ b/modules/core/src/lapack.cpp
@@ -1398,10 +1398,7 @@ bool cv::solve( InputArray _src, InputArray _src2arg, OutputArray _dst, int meth
 
 /////////////////// finding eigenvalues and eigenvectors of a symmetric matrix ///////////////
 
-namespace cv
-{
-
-static bool eigen( InputArray _src, OutputArray _evals, OutputArray _evects, bool computeEvects, int, int )
+bool cv::eigen( InputArray _src, bool computeEvects, OutputArray _evals, OutputArray _evects )
 {
     Mat src = _src.getMat();
     int type = src.type();
@@ -1431,17 +1428,14 @@ static bool eigen( InputArray _src, OutputArray _evals, OutputArray _evects, boo
     return ok;
 }
 
-}
-    
-bool cv::eigen( InputArray src, OutputArray evals, int lowindex, int highindex )
+bool cv::eigen( InputArray src, OutputArray evals, int, int )
 {
-    return eigen(src, evals, noArray(), false, lowindex, highindex);
+    return eigen(src, false, evals, noArray());
 }
 
-bool cv::eigen( InputArray src, OutputArray evals, OutputArray evects,
-                int lowindex, int highindex )
+bool cv::eigen( InputArray src, OutputArray evals, OutputArray evects, int, int)
 {
-    return eigen(src, evals, evects, true, lowindex, highindex);
+    return eigen(src, true, evals, evects);
 }
 
 namespace cv
@@ -1568,6 +1562,17 @@ void SVD::backSubst( InputArray rhs, OutputArray dst ) const
 }
 
 
+void cv::SVDecomp(InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags)
+{
+    SVD::compute(src, w, u, vt, flags);
+}
+
+void cv::SVBackSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst)
+{
+    SVD::backSubst(w, u, vt, rhs, dst);
+}
+
+
 CV_IMPL double
 cvDet( const CvArr* arr )
 {
@@ -1632,14 +1637,31 @@ CV_IMPL void
 cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
            int lowindex, int highindex)
 {
-    cv::Mat src = cv::cvarrToMat(srcarr), evals = cv::cvarrToMat(evalsarr);
+    cv::Mat src = cv::cvarrToMat(srcarr), evals0 = cv::cvarrToMat(evalsarr), evals = evals0;
     if( evectsarr )
     {
-        cv::Mat evects = cv::cvarrToMat(evectsarr);
+        cv::Mat evects0 = cv::cvarrToMat(evectsarr), evects = evects0;
         eigen(src, evals, evects, lowindex, highindex);
+        if( evects0.data != evects.data )
+        {
+            uchar* p = evects0.data;
+            evects.convertTo(evects0, evects0.type());
+            CV_Assert( p == evects0.data );
+        }
     }
     else
         eigen(src, evals, lowindex, highindex);
+    if( evals0.data != evals.data )
+    {
+        uchar* p = evals0.data;
+        if( evals0.size() == evals.size() )
+            evals.convertTo(evals0, evals0.type());
+        else if( evals0.type() == evals.type() )
+            cv::transpose(evals, evals0);
+        else
+            cv::Mat(evals.t()).convertTo(evals0, evals0.type());
+        CV_Assert( p == evals0.data );
+    }
 }
 
 
diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp
index 83970fa847..88056e012f 100644
--- a/modules/core/src/mathfuncs.cpp
+++ b/modules/core/src/mathfuncs.cpp
@@ -1990,8 +1990,8 @@ bool checkRange(InputArray _src, bool quiet, Point* pt,
 
     if( depth < CV_32F )
     {
-        double m = 0, M = 0, badValue = 0;
-        Point mp, MP, badPt(-1,-1);
+        double m = 0, M = 0;
+        Point mp, MP;
         minMaxLoc(src.reshape(1,0), &m, &M, &mp, &MP);
         if( M >= maxVal )
         {
diff --git a/modules/core/src/matmul.cpp b/modules/core/src/matmul.cpp
index 28767bfe33..45cb158220 100644
--- a/modules/core/src/matmul.cpp
+++ b/modules/core/src/matmul.cpp
@@ -2713,7 +2713,7 @@ double Mat::dot(InputArray _mat) const
     {
         size_t len = total()*cn;
         if( len == (size_t)(int)len )
-            return func(data, mat.data, len);
+            return func(data, mat.data, (int)len);
     }
 
     const Mat* arrays[] = {this, &mat, 0};
@@ -2884,6 +2884,34 @@ Mat PCA::backProject(InputArray data) const
 
 }
 
+void cv::PCACompute(InputArray data, InputOutputArray mean,
+                    OutputArray eigenvectors, int maxComponents)
+{
+    PCA pca;
+    pca(data, mean, 0, maxComponents);
+    pca.mean.copyTo(mean);
+    pca.eigenvectors.copyTo(eigenvectors);
+}
+    
+void cv::PCAProject(InputArray data, InputArray mean,
+                    InputArray eigenvectors, OutputArray result)
+{
+    PCA pca;
+    pca.mean = mean.getMat();
+    pca.eigenvectors = eigenvectors.getMat();
+    pca.project(data, result);
+}
+
+void cv::PCABackProject(InputArray data, InputArray mean,
+                    InputArray eigenvectors, OutputArray result)
+{
+    PCA pca;
+    pca.mean = mean.getMat();
+    pca.eigenvectors = eigenvectors.getMat();
+    pca.backProject(data, result);
+}
+
+
 /****************************************************************************************\
 *                                    Earlier API                                         *
 \****************************************************************************************/
diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp
index f0905a180b..95b0c4e36f 100644
--- a/modules/core/src/matrix.cpp
+++ b/modules/core/src/matrix.cpp
@@ -585,6 +585,11 @@ void Mat::push_back(const Mat& elems)
         push_back(tmp);
         return;
     }
+	if( !data )
+	{
+		*this = elems.clone();
+		return;
+	}
 
     size.p[0] = elems.size.p[0];
     bool eq = size == elems.size;
@@ -928,7 +933,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
     if( k == MAT )
     {
         const Mat& m = *(const Mat*)obj;
-        size_t i, n = m.size[0];
+        int i, n = (int)m.size[0];
         mv.resize(n);
         
         for( i = 0; i < n; i++ )
@@ -940,7 +945,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
     if( k == EXPR )
     {
         Mat m = *(const MatExpr*)obj;
-        size_t i, n = m.size[0];
+        int i, n = m.size[0];
         mv.resize(n);
         
         for( i = 0; i < n; i++ )
@@ -980,7 +985,7 @@ void _InputArray::getMatVector(vector<Mat>& mv) const
     if( k == STD_VECTOR_VECTOR )
     {
         const vector<vector<uchar> >& vv = *(const vector<vector<uchar> >*)obj;
-        size_t i, n = vv.size();
+        int i, n = (int)vv.size();
         int t = CV_MAT_TYPE(flags);
         mv.resize(n);
         
@@ -2200,7 +2205,7 @@ static void generateCentersPP(const Mat& _data, Mat& _out_centers,
 {
     int i, j, k, dims = _data.cols, N = _data.rows;
     const float* data = _data.ptr<float>(0);
-    int step = (int)(_data.step/sizeof(data[0]));
+    size_t step = _data.step/sizeof(data[0]);
     vector<int> _centers(K);
     int* centers = &_centers[0];
     vector<float> _dist(N*3);
@@ -2795,7 +2800,7 @@ NAryMatIterator& NAryMatIterator::operator ++()
             const Mat& A = *arrays[i];
             if( !A.data )
                 continue;
-            int _idx = idx;
+            int _idx = (int)idx;
             uchar* data = A.data;
             for( int j = iterdepth-1; j >= 0 && _idx > 0; j-- )
             {
diff --git a/modules/core/src/out.cpp b/modules/core/src/out.cpp
index eeca5a1fa2..366f5cf05c 100644
--- a/modules/core/src/out.cpp
+++ b/modules/core/src/out.cpp
@@ -127,7 +127,8 @@ static void writeMat(std::ostream& out, const Mat& m, char rowsep, char elembrac
     {
         if(orowbrace)
             out << orowbrace;
-        writeElems(out, m.ptr(i), m.cols, type, elembrace);
+        if( m.data )
+            writeElems(out, m.ptr(i), m.cols, type, elembrace);
         if(orowbrace)
             out << crowbrace << (i+1 < m.rows ? ", " : "");
         if(i+1 < m.rows)
diff --git a/modules/core/src/precomp.hpp b/modules/core/src/precomp.hpp
index 14a3437a7d..efd8c61e79 100644
--- a/modules/core/src/precomp.hpp
+++ b/modules/core/src/precomp.hpp
@@ -65,6 +65,10 @@
 #include <stdlib.h>
 #include <string.h>
 
+#ifdef HAVE_TEGRA_OPTIMIZATION
+#include "opencv2/core/core_tegra.hpp"
+#endif
+
 namespace cv
 {
 
diff --git a/modules/core/src/rand.cpp b/modules/core/src/rand.cpp
index fb68d38847..e143256c88 100644
--- a/modules/core/src/rand.cpp
+++ b/modules/core/src/rand.cpp
@@ -812,6 +812,11 @@ void cv::randShuffle( InputOutputArray _dst, double iterFactor, RNG* _rng )
     func( dst, rng, iterFactor );
 }
 
+void cv::randShuffle_( InputOutputArray _dst, double iterFactor )
+{
+    randShuffle(_dst, iterFactor);
+}
+
 CV_IMPL void
 cvRandArr( CvRNG* _rng, CvArr* arr, int disttype, CvScalar param1, CvScalar param2 )
 {
diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp
index e1dc88e52e..307a68b250 100644
--- a/modules/core/src/stat.cpp
+++ b/modules/core/src/stat.cpp
@@ -590,7 +590,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
     }
     
     double scale = nz0 ? 1./nz0 : 0.;
-    for( int k = 0; k < cn; k++ )
+    for( k = 0; k < cn; k++ )
     {
         s[k] *= scale;
         sq[k] = std::sqrt(std::max(sq[k]*scale - s[k]*s[k], 0.));
diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp
index bdd44d2928..2922cdaf8f 100644
--- a/modules/core/src/system.cpp
+++ b/modules/core/src/system.cpp
@@ -85,6 +85,17 @@
 
 #include <stdarg.h>
 
+#if defined __linux__ || defined __APPLE__
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h> 
+#if defined ANDROID
+#include <sys/sysconf.h>
+#else
+#include <sys/sysctl.h>
+#endif
+#endif
+
 namespace cv
 {
 
@@ -192,7 +203,7 @@ struct IPPInitializer
 
 IPPInitializer ippInitializer;
 #else
-volatile bool useOptimizedFlag = false;
+volatile bool useOptimizedFlag = true;
 #endif
 
 volatile bool USE_SSE2 = false;
@@ -365,6 +376,41 @@ int getThreadNum(void)
 #endif
 }
 
+int getNumberOfCPUs(void)
+{
+#if defined WIN32 || defined _WIN32
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo( &sysinfo );
+    
+    return (int)sysinfo.dwNumberOfProcessors;
+#elif defined __linux__
+    return (int)sysconf( _SC_NPROCESSORS_ONLN );
+#elif defined __APPLE__
+    int numCPU=0;
+    int mib[4];
+    size_t len = sizeof(numCPU); 
+    
+    /* set the mib for hw.ncpu */
+    mib[0] = CTL_HW;
+    mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
+    
+    /* get the number of CPUs from the system */
+    sysctl(mib, 2, &numCPU, &len, NULL, 0);
+    
+    if( numCPU < 1 ) 
+    {
+        mib[1] = HW_NCPU;
+        sysctl( mib, 2, &numCPU, &len, NULL, 0 );
+        
+        if( numCPU < 1 )
+            numCPU = 1;
+    }
+    
+    return (int)numCPU;
+#else
+    return 1;
+#endif
+}
 
 string format( const char* fmt, ... )
 {
diff --git a/modules/core/test/test_arithm.cpp b/modules/core/test/test_arithm.cpp
index b20747085c..dc1215ae3f 100644
--- a/modules/core/test/test_arithm.cpp
+++ b/modules/core/test/test_arithm.cpp
@@ -559,7 +559,8 @@ static void inRange(const Mat& src, const Mat& lb, const Mat& rb, Mat& dst)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth(), cn = src.channels();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -606,7 +607,8 @@ static void inRangeS(const Mat& src, const Scalar& lb, const Scalar& rb, Mat& ds
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth(), cn = src.channels();
     double lbuf[4], rbuf[4];
     int wtype = CV_MAKETYPE(depth <= CV_32S ? CV_32S : depth, cn);
     scalarToRawData(lb, lbuf, wtype, cn);
@@ -900,7 +902,8 @@ static void exp(const Mat& src, Mat& dst)
     
     NAryMatIterator it(arrays, planes);
     size_t j, total = planes[0].total()*src.channels();
-    int i, nplanes = it.nplanes, depth = src.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -928,7 +931,8 @@ static void log(const Mat& src, Mat& dst)
     
     NAryMatIterator it(arrays, planes);
     size_t j, total = planes[0].total()*src.channels();
-    int i, nplanes = it.nplanes, depth = src.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -1017,7 +1021,8 @@ static void cartToPolar(const Mat& mx, const Mat& my, Mat& mmag, Mat& mangle, bo
     
     NAryMatIterator it(arrays, planes);
     size_t j, total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = mx.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = mx.depth();
     double scale = angleInDegrees ? 180/CV_PI : 1;
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1260,8 +1265,8 @@ struct MinMaxLocOp : public BaseElemWiseOp
     void saveOutput(const vector<int>& minidx, const vector<int>& maxidx,
                     double minval, double maxval, Mat& dst)
     {
-        size_t i, ndims = minidx.size();
-        dst.create(1, (int)(ndims*2 + 2), CV_64FC1);
+        int i, ndims = (int)minidx.size();
+        dst.create(1, ndims*2 + 2, CV_64FC1);
         
         for( i = 0; i < ndims; i++ )
         {
diff --git a/modules/core/test/test_dxt.cpp b/modules/core/test/test_dxt.cpp
index be6826e1d9..fd3fdd6fd5 100644
--- a/modules/core/test/test_dxt.cpp
+++ b/modules/core/test/test_dxt.cpp
@@ -170,9 +170,9 @@ static void DCT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
     w = wave.ptr<double>();
     
     if( !_src.isContinuous() )
-        srcstep = _src.step/_src.elemSize();
+        srcstep = (int)(_src.step/_src.elemSize());
     if( !_dst.isContinuous() )
-        dststep = _dst.step/_dst.elemSize();
+        dststep = (int)(_dst.step/_dst.elemSize());
     
     if( _src.type() == CV_32FC1 )
     {
@@ -279,10 +279,10 @@ static void convertFromCCS( const Mat& _src0, const Mat& _src1, Mat& _dst, int f
         int srcstep = cn, dststep = 1;
         
         if( !_dst.isContinuous() )
-            dststep = _dst.step/_dst.elemSize();
+            dststep = (int)(_dst.step/_dst.elemSize());
         
         if( !_src0.isContinuous() )
-            srcstep = _src0.step/_src0.elemSize1();
+            srcstep = (int)(_src0.step/_src0.elemSize1());
         
         if( _dst.depth() == CV_32F )
         {
diff --git a/modules/core/test/test_math.cpp b/modules/core/test/test_math.cpp
index 23e03073a1..0b9dbd5311 100644
--- a/modules/core/test/test_math.cpp
+++ b/modules/core/test/test_math.cpp
@@ -1954,7 +1954,7 @@ void Core_SVDTest::prepare_to_validation( int /*test_case_idx*/ )
     }
     
     w = &test_mat[TEMP][0];
-    step = w->rows == 1 ? 1 : w->step1();
+    step = w->rows == 1 ? 1 : (int)w->step1();
     for( i = 0; i < min_size; i++ )
     {
         double normval = 0, aii;
diff --git a/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst b/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst
index 5983c463cc..a750eb5d2a 100644
--- a/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst
+++ b/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst
@@ -55,23 +55,15 @@ Computes the descriptors for a set of keypoints detected in an image (first vari
 
 .. ocv:function:: void DescriptorExtractor::compute( const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors ) const
 
-    :param image: Image.
-
-    :param keypoints: Keypoints. Keypoints for which a descriptor cannot be computed are removed. Sometimes new keypoints can be added, for example: ``SIFT`` duplicates keypoint with several dominant orientations (for each orientation).
-
-    :param descriptors: Descriptors. Row ``i`` is the descriptor for keypoint ``i``.
-
 .. ocv:function:: void DescriptorExtractor::compute( const vector<Mat>& images, vector<vector<KeyPoint> >& keypoints, vector<Mat>& descriptors ) const
 
+    :param image: Image.
+
     :param images: Image set.
 
-    :param keypoints: Input keypoints collection. ``keypoints[i]`` are keypoints
-                          detected in ``images[i]`` . Keypoints for which a descriptor
-                          cannot be computed are removed.
-
-    :param descriptors: Descriptor collection. ``descriptors[i]`` are descriptors computed for a ``keypoints[i]`` set.
-
+    :param keypoints: Input collection of keypoints. Keypoints for which a descriptor cannot be computed are removed. Sometimes new keypoints can be added, for example: ``SIFT`` duplicates keypoint with several dominant orientations (for each orientation).
 
+    :param descriptors: Computed descriptors. In the second variant of the method ``descriptors[i]`` are descriptors computed for a ``keypoints[i]`. Row ``j`` is the ``keypoints`` (or ``keypoints[i]``) is the descriptor for keypoint ``j``-th keypoint.
 
 DescriptorExtractor::read
 -----------------------------
@@ -119,7 +111,7 @@ SiftDescriptorExtractor
 .. ocv:class:: SiftDescriptorExtractor
 
 Wrapping class for computing descriptors by using the
-:ocv:class::`SIFT` class. ::
+:ocv:class:`SIFT` class. ::
 
     class SiftDescriptorExtractor : public DescriptorExtractor
     {
diff --git a/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst b/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst
index 31ac5a1044..8ec9c4bc18 100644
--- a/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst
+++ b/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst
@@ -290,7 +290,7 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
     template<> struct Accumulator<short>  { typedef int Type; };
 
     /*
-     * Squared Euclidean distance functor
+     * Euclidean distance functor
      */
     template<class T>
     struct L2
@@ -300,6 +300,20 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
 
         ResultType operator()( const T* a, const T* b, int size ) const;
     };
+    
+    /*
+     * Squared Euclidean distance functor
+     */
+    template<class T>
+    struct SL2
+    {
+        typedef T ValueType;
+        typedef typename Accumulator<T>::Type ResultType;
+
+        ResultType operator()( const T* a, const T* b, int size ) const;
+    };
+    // Note: in case of SL2 distance a parameter maxDistance in the method DescriptorMatcher::radiusMatch 
+    // is a squared maximum distance in L2.
 
     /*
      * Manhattan distance (city block distance) functor
@@ -311,7 +325,6 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
         typedef typename Accumulator<T>::Type ResultType;
 
         ResultType operator()( const T* a, const T* b, int size ) const;
-        ...
     };
 
     /*
@@ -334,7 +347,6 @@ For efficiency, ``BruteForceMatcher`` is used as a template parameterized with t
 
         ResultType operator()( const unsigned char* a, const unsigned char* b,
                                int size ) const;
-        ...
     };
 
 
diff --git a/modules/features2d/doc/common_interfaces_of_feature_detectors.rst b/modules/features2d/doc/common_interfaces_of_feature_detectors.rst
index bc0984a603..5be705308f 100644
--- a/modules/features2d/doc/common_interfaces_of_feature_detectors.rst
+++ b/modules/features2d/doc/common_interfaces_of_feature_detectors.rst
@@ -100,19 +100,17 @@ Detects keypoints in an image (first variant) or image set (second variant).
 
 .. ocv:function:: void FeatureDetector::detect( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const
 
+.. ocv:function:: void FeatureDetector::detect( const vector<Mat>& images, vector<vector<KeyPoint> >& keypoints, const vector<Mat>& masks=vector<Mat>() ) const
+
     :param image: Image.
 
-    :param keypoints: Detected keypoints.
-
-    :param mask: Mask specifying where to look for keypoints (optional). It must be a char matrix with non-zero values in the region of interest.
-
-.. ocv:function:: void FeatureDetector::detect( const vector<Mat>& images,                                                            vector<vector<KeyPoint> >& keypoints,                                                             const vector<Mat>& masks=vector<Mat>() ) const
-
     :param images: Image set.
 
-    :param keypoints: Collection of keypoints detected in input images. ``keypoints[i]`` is a set of keypoints detected in ``images[i]`` .
+    :param keypoints: The detected keypoints. In the second variant of the method ``keypoints[i]`` is a set of keypoints detected in ``images[i]`` .
 
-    :param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]`` .                     Each element of the ``masks``  vector must be a char matrix with non-zero values in the region of interest.
+    :param mask: Mask specifying where to look for keypoints (optional). It must be a 8-bit integer matrix with non-zero values in the region of interest.
+
+    :param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]``.
 
 FeatureDetector::read
 -------------------------
diff --git a/modules/features2d/doc/object_categorization.rst b/modules/features2d/doc/object_categorization.rst
index 416ad5b5d2..a5f82b5bf7 100644
--- a/modules/features2d/doc/object_categorization.rst
+++ b/modules/features2d/doc/object_categorization.rst
@@ -94,6 +94,7 @@ BOWKMeansTrainer
 
 BOWKMeansTrainer::BOWKMeansTrainer
 ----------------------------------
+
 The constructor.
 
 .. ocv:function:: BOWKMeansTrainer::BOWKMeansTrainer( int clusterCount, const TermCriteria& termcrit=TermCriteria(), int attempts=3, int flags=KMEANS_PP_CENTERS )
@@ -193,6 +194,7 @@ Returns an image discriptor size if the vocabulary is set. Otherwise, it returns
 
 BOWImgDescriptorExtractor::descriptorType
 ---------------------------------------------
+
 Returns an image descriptor type.
 
 .. ocv:function:: int BOWImgDescriptorExtractor::descriptorType() const
diff --git a/modules/features2d/include/opencv2/features2d/features2d.hpp b/modules/features2d/include/opencv2/features2d/features2d.hpp
index 9da0f87a4f..b7281f8b61 100644
--- a/modules/features2d/include/opencv2/features2d/features2d.hpp
+++ b/modules/features2d/include/opencv2/features2d/features2d.hpp
@@ -44,7 +44,7 @@
 #define __OPENCV_FEATURES_2D_HPP__
 
 #include "opencv2/core/core.hpp"
-#include "opencv2/flann/flann.hpp"
+#include "opencv2/flann/miniflann.hpp"
 
 #ifdef __cplusplus
 #include <limits>
@@ -1583,10 +1583,16 @@ public:
 
       bool filterByConvexity;
       float minConvexity, maxConvexity;
+
+      void read( const FileNode& fn );
+      void write( FileStorage& fs ) const;
   };
 
   SimpleBlobDetector(const SimpleBlobDetector::Params &parameters = SimpleBlobDetector::Params());
 
+  virtual void read( const FileNode& fn );
+  virtual void write( FileStorage& fs ) const;
+
 protected:
   struct CV_EXPORTS Center
   {
@@ -1618,11 +1624,15 @@ public:
 
         bool varyXyStepWithScale;
         bool varyImgBoundWithScale;
+
+        void read( const FileNode& fn );
+        void write( FileStorage& fs ) const;
     };
 
     DenseFeatureDetector( const DenseFeatureDetector::Params& params=DenseFeatureDetector::Params() );
     
-	// TODO implement read/write
+    virtual void read( const FileNode& fn );
+    virtual void write( FileStorage& fs ) const;
 
 protected:
     virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
@@ -1919,7 +1929,7 @@ protected:
  * - if you know the integral image, use setIntegralImage so that it is not recomputed. This calls
  * setStepSize automatically
  */
-class OrbDescriptorExtractor : public cv::DescriptorExtractor
+class CV_EXPORTS OrbDescriptorExtractor : public cv::DescriptorExtractor
 {
 public:
   /** default constructor
@@ -2052,6 +2062,9 @@ public:
     // bytes is a length of descriptor in bytes. It can be equal 16, 32 or 64 bytes.
     BriefDescriptorExtractor( int bytes = 32 );
 
+    virtual void read( const FileNode& );
+    virtual void write( FileStorage& ) const;
+
     virtual int descriptorSize() const;
     virtual int descriptorType() const;
 
@@ -2084,6 +2097,27 @@ template<> struct Accumulator<short>  { typedef float Type; };
  * Squared Euclidean distance functor
  */
 template<class T>
+struct CV_EXPORTS SL2
+{
+    typedef T ValueType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    ResultType operator()( const T* a, const T* b, int size ) const
+    {
+        ResultType result = ResultType();
+        for( int i = 0; i < size; i++ )
+        {
+            ResultType diff = (ResultType)(a[i] - b[i]);
+            result += diff*diff;
+        }
+        return result;
+    }
+};
+
+/*
+ * Euclidean distance functor
+ */
+template<class T>
 struct CV_EXPORTS L2
 {
     typedef T ValueType;
@@ -2367,6 +2401,7 @@ Ptr<DescriptorMatcher> BruteForceMatcher<Distance>::clone( bool emptyTrainData )
     BruteForceMatcher* matcher = new BruteForceMatcher(distance);
     if( !emptyTrainData )
     {
+        matcher->trainDescCollection.resize(trainDescCollection.size());
         std::transform( trainDescCollection.begin(), trainDescCollection.end(),
                         matcher->trainDescCollection.begin(), clone_op );
     }
@@ -2391,77 +2426,77 @@ template<class Distance>
 inline void BruteForceMatcher<Distance>::commonKnnMatchImpl( BruteForceMatcher<Distance>& matcher,
                           const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
                           const vector<Mat>& masks, bool compactResult )
- {
-     typedef typename Distance::ValueType ValueType;
-     typedef typename Distance::ResultType DistanceType;
-	 CV_DbgAssert( !queryDescriptors.empty() );
-     CV_Assert( DataType<ValueType>::type == queryDescriptors.type() );
+{
+    typedef typename Distance::ValueType ValueType;
+    typedef typename Distance::ResultType DistanceType;
+    CV_DbgAssert( !queryDescriptors.empty() );
+    CV_Assert( DataType<ValueType>::type == queryDescriptors.type() );
      
-     int dimension = queryDescriptors.cols;
-     matches.reserve(queryDescriptors.rows);
+    int dimension = queryDescriptors.cols;
+    matches.reserve(queryDescriptors.rows);
 
-     size_t imgCount = matcher.trainDescCollection.size();
-     vector<Mat> allDists( imgCount ); // distances between one query descriptor and all train descriptors
-     for( size_t i = 0; i < imgCount; i++ )
+    size_t imgCount = matcher.trainDescCollection.size();
+    vector<Mat> allDists( imgCount ); // distances between one query descriptor and all train descriptors
+    for( size_t i = 0; i < imgCount; i++ )
         allDists[i] = Mat( 1, matcher.trainDescCollection[i].rows, DataType<DistanceType>::type );
 
-     for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
-     {
-         if( matcher.isMaskedOut( masks, qIdx ) )
-         {
-             if( !compactResult ) // push empty vector
-                 matches.push_back( vector<DMatch>() );
-         }
-         else
-         {
-             // 1. compute distances between i-th query descriptor and all train descriptors
-             for( size_t iIdx = 0; iIdx < imgCount; iIdx++ )
-             {
-                 CV_Assert( DataType<ValueType>::type == matcher.trainDescCollection[iIdx].type() ||  matcher.trainDescCollection[iIdx].empty() );
-				 CV_Assert( queryDescriptors.cols == matcher.trainDescCollection[iIdx].cols || 
-				            matcher.trainDescCollection[iIdx].empty() );
+    for( int qIdx = 0; qIdx < queryDescriptors.rows; qIdx++ )
+    {
+        if( matcher.isMaskedOut( masks, qIdx ) )
+        {
+            if( !compactResult ) // push empty vector
+                matches.push_back( vector<DMatch>() );
+        }
+        else
+        {
+            // 1. compute distances between i-th query descriptor and all train descriptors
+            for( size_t iIdx = 0; iIdx < imgCount; iIdx++ )
+            {
+                CV_Assert( DataType<ValueType>::type == matcher.trainDescCollection[iIdx].type() ||  matcher.trainDescCollection[iIdx].empty() );
+                CV_Assert( queryDescriptors.cols == matcher.trainDescCollection[iIdx].cols ||
+                           matcher.trainDescCollection[iIdx].empty() );
 
-                 const ValueType* d1 = (const ValueType*)(queryDescriptors.data + queryDescriptors.step*qIdx);
-                 allDists[iIdx].setTo( Scalar::all(std::numeric_limits<DistanceType>::max()) );
-                 for( int tIdx = 0; tIdx < matcher.trainDescCollection[iIdx].rows; tIdx++ )
-                 {
-                     if( masks.empty() || matcher.isPossibleMatch(masks[iIdx], qIdx, tIdx) )
-                     {
-                         const ValueType* d2 = (const ValueType*)(matcher.trainDescCollection[iIdx].data +
-                                                                  matcher.trainDescCollection[iIdx].step*tIdx);
-                         allDists[iIdx].at<DistanceType>(0, tIdx) = matcher.distance(d1, d2, dimension);
-                     }
-                 }
-             }
+                const ValueType* d1 = (const ValueType*)(queryDescriptors.data + queryDescriptors.step*qIdx);
+                allDists[iIdx].setTo( Scalar::all(std::numeric_limits<DistanceType>::max()) );
+                for( int tIdx = 0; tIdx < matcher.trainDescCollection[iIdx].rows; tIdx++ )
+                {
+                    if( masks.empty() || matcher.isPossibleMatch(masks[iIdx], qIdx, tIdx) )
+                    {
+                        const ValueType* d2 = (const ValueType*)(matcher.trainDescCollection[iIdx].data +
+                                                                 matcher.trainDescCollection[iIdx].step*tIdx);
+                        allDists[iIdx].at<DistanceType>(0, tIdx) = matcher.distance(d1, d2, dimension);
+                    }
+                }
+            }
 
-             // 2. choose k nearest matches for query[i]
-             matches.push_back( vector<DMatch>() );
-             vector<vector<DMatch> >::reverse_iterator curMatches = matches.rbegin();
-             for( int k = 0; k < knn; k++ )
-             {
-                 DMatch bestMatch;
-                 bestMatch.distance = std::numeric_limits<float>::max();
-                 for( size_t iIdx = 0; iIdx < imgCount; iIdx++ )
-                 {
-                     if( !allDists[iIdx].empty() )
-                     {
-                         double minVal;
-                         Point minLoc;
-                         minMaxLoc( allDists[iIdx], &minVal, 0, &minLoc, 0 );
-                         if( minVal < bestMatch.distance )
-                                 bestMatch = DMatch( qIdx, minLoc.x, (int)iIdx, (float)minVal );
-                     }
-                 }
-                 if( bestMatch.trainIdx == -1 )
-                     break;
+            // 2. choose k nearest matches for query[i]
+            matches.push_back( vector<DMatch>() );
+            vector<vector<DMatch> >::reverse_iterator curMatches = matches.rbegin();
+            for( int k = 0; k < knn; k++ )
+            {
+                DMatch bestMatch;
+                bestMatch.distance = std::numeric_limits<float>::max();
+                for( size_t iIdx = 0; iIdx < imgCount; iIdx++ )
+                {
+                    if( !allDists[iIdx].empty() )
+                    {
+                        double minVal;
+                        Point minLoc;
+                        minMaxLoc( allDists[iIdx], &minVal, 0, &minLoc, 0 );
+                        if( minVal < bestMatch.distance )
+                            bestMatch = DMatch( qIdx, minLoc.x, (int)iIdx, (float)minVal );
+                    }
+                }
+                if( bestMatch.trainIdx == -1 )
+                    break;
 
-                 allDists[bestMatch.imgIdx].at<DistanceType>(0, bestMatch.trainIdx) = std::numeric_limits<DistanceType>::max();
-                 curMatches->push_back( bestMatch );
-             }
-             //TODO should already be sorted at this point?
-             std::sort( curMatches->begin(), curMatches->end() );
-         }
-     }
+                allDists[bestMatch.imgIdx].at<DistanceType>(0, bestMatch.trainIdx) = std::numeric_limits<DistanceType>::max();
+                curMatches->push_back( bestMatch );
+            }
+            //TODO should already be sorted at this point?
+            std::sort( curMatches->begin(), curMatches->end() );
+        }
+    }
 }
 
 template<class Distance>
@@ -2536,6 +2571,11 @@ public:
     virtual void add( const vector<Mat>& descriptors );
     virtual void clear();
 
+    // Reads matcher object from a file node
+    virtual void read( const FileNode& );
+    // Writes matcher object to a file storage
+    virtual void write( FileStorage& ) const;
+
     virtual void train();
     virtual bool isMaskSupported() const;
 	
diff --git a/modules/features2d/src/blobdetector.cpp b/modules/features2d/src/blobdetector.cpp
index 1242507543..4fa920787a 100644
--- a/modules/features2d/src/blobdetector.cpp
+++ b/modules/features2d/src/blobdetector.cpp
@@ -84,11 +84,79 @@ SimpleBlobDetector::Params::Params()
 	maxConvexity = std::numeric_limits<float>::max();
 }
 
+void SimpleBlobDetector::Params::read(const cv::FileNode& fn )
+{
+    thresholdStep = fn["thresholdStep"];
+    minThreshold = fn["minThreshold"];
+    maxThreshold = fn["maxThreshold"];
+
+    minRepeatability = (size_t)(int)fn["minRepeatability"];
+    minDistBetweenBlobs = fn["minDistBetweenBlobs"];
+
+    filterByColor = (int)fn["filterByColor"] != 0 ? true : false;
+    blobColor = (uchar)(int)fn["blobColor"];
+
+    filterByArea = (int)fn["filterByArea"] != 0 ? true : false;
+    minArea = fn["minArea"];
+    maxArea = fn["maxArea"];
+
+    filterByCircularity = (int)fn["filterByCircularity"] != 0 ? true : false;
+    minCircularity = fn["minCircularity"];
+    maxCircularity = fn["maxCircularity"];
+
+    filterByInertia = (int)fn["filterByInertia"] != 0 ? true : false;
+    minInertiaRatio = fn["minInertiaRatio"];
+    maxInertiaRatio = fn["maxInertiaRatio"];
+
+    filterByConvexity = (int)fn["filterByConvexity"] != 0 ? true : false;
+    minConvexity = fn["minConvexity"];
+    maxConvexity = fn["maxConvexity"];
+}
+
+void SimpleBlobDetector::Params::write(cv::FileStorage& fs) const
+{
+    fs << "thresholdStep" << thresholdStep;
+    fs << "minThreshold" << minThreshold;
+    fs << "maxThreshold" << maxThreshold;
+
+    fs << "minRepeatability" << (int)minRepeatability;
+    fs << "minDistBetweenBlobs" << minDistBetweenBlobs;
+
+    fs << "filterByColor" << (int)filterByColor;
+    fs << "blobColor" << (int)blobColor;
+
+    fs << "filterByArea" << (int)filterByArea;
+    fs << "minArea" << minArea;
+    fs << "maxArea" << maxArea;
+
+    fs << "filterByCircularity" << (int)filterByCircularity;
+    fs << "minCircularity" << minCircularity;
+    fs << "maxCircularity" << maxCircularity;
+
+    fs << "filterByInertia" << (int)filterByInertia;
+    fs << "minInertiaRatio" << minInertiaRatio;
+    fs << "maxInertiaRatio" << maxInertiaRatio;
+
+    fs << "filterByConvexity" << (int)filterByConvexity;
+    fs << "minConvexity" << minConvexity;
+    fs << "maxConvexity" << maxConvexity;
+}
+
 SimpleBlobDetector::SimpleBlobDetector(const SimpleBlobDetector::Params &parameters) :
 params(parameters)
 {
 }
 
+void SimpleBlobDetector::read( const cv::FileNode& fn )
+{
+    params.read(fn);
+}
+
+void SimpleBlobDetector::write( cv::FileStorage& fs ) const
+{
+    params.write(fs);
+}
+
 void SimpleBlobDetector::findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, vector<Center> &centers) const
 {
 	(void)image;
diff --git a/modules/features2d/src/brief.cpp b/modules/features2d/src/brief.cpp
index bde3127590..29b5148bf6 100644
--- a/modules/features2d/src/brief.cpp
+++ b/modules/features2d/src/brief.cpp
@@ -188,6 +188,31 @@ int BriefDescriptorExtractor::descriptorType() const
     return CV_8UC1;
 }
 
+void BriefDescriptorExtractor::read( const FileNode& fn)
+{
+    int descriptorSize = fn["descriptorSize"];
+    switch (descriptorSize)
+    {
+        case 16:
+            test_fn_ = pixelTests16;
+            break;
+        case 32:
+            test_fn_ = pixelTests32;
+            break;
+        case 64:
+            test_fn_ = pixelTests64;
+            break;
+        default:
+            CV_Error(CV_StsBadArg, "descriptorSize must be 16, 32, or 64");
+    }
+    bytes_ = descriptorSize;
+}
+
+void BriefDescriptorExtractor::write( FileStorage& fs) const
+{
+    fs << "descriptorSize" << bytes_;
+}
+
 void BriefDescriptorExtractor::computeImpl(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const
 {
     // Construct integral image for fast smoothing (box filter)
diff --git a/modules/features2d/src/calonder.cpp b/modules/features2d/src/calonder.cpp
index d7a74eea20..c933b20a0e 100644
--- a/modules/features2d/src/calonder.cpp
+++ b/modules/features2d/src/calonder.cpp
@@ -618,7 +618,7 @@ void RandomizedTree::write(std::ostream &os) const
   os.write((char*)(&classes_), sizeof(classes_));
   os.write((char*)(&depth_), sizeof(depth_));
 
-  os.write((char*)(&nodes_[0]), nodes_.size() * sizeof(nodes_[0]));
+  os.write((char*)(&nodes_[0]), (int)(nodes_.size() * sizeof(nodes_[0])));
   for (int i=0; i<num_leaves_; i++) {
     os.write((char*)posteriors_[i], classes_ * sizeof(*posteriors_[0]));
   }
diff --git a/modules/features2d/src/descriptors.cpp b/modules/features2d/src/descriptors.cpp
index 7c8977ca2f..40e6ee6ab5 100644
--- a/modules/features2d/src/descriptors.cpp
+++ b/modules/features2d/src/descriptors.cpp
@@ -261,6 +261,7 @@ void OrbDescriptorExtractor::computeImpl(const cv::Mat& image, std::vector<cv::K
 void OrbDescriptorExtractor::read(const cv::FileNode& fn)
 {
   params_.read(fn);
+  orb_ = ORB(0, params_);
 }
 void OrbDescriptorExtractor::write(cv::FileStorage& fs) const
 {
diff --git a/modules/features2d/src/detectors.cpp b/modules/features2d/src/detectors.cpp
index 6d8388e23f..80438f2c37 100644
--- a/modules/features2d/src/detectors.cpp
+++ b/modules/features2d/src/detectors.cpp
@@ -126,6 +126,14 @@ Ptr<FeatureDetector> FeatureDetector::create( const string& detectorType )
         params.useHarrisDetector = true;
         fd = new GoodFeaturesToTrackDetector(params);
     }
+    else if( !detectorType.compare( "Dense" ) )
+    {
+        fd = new DenseFeatureDetector();
+    }
+    else if( !detectorType.compare( "SimpleBlob" ) )
+    {
+        fd = new SimpleBlobDetector();
+    }
     else if( (pos=detectorType.find("Grid")) == 0 )
     {
         pos += string("Grid").size();
@@ -445,7 +453,7 @@ void ORB::CommonParams::read(const FileNode& fn)
 {
   scale_factor_ = fn["scaleFactor"];
   n_levels_ = int(fn["nLevels"]);
-  first_level_ = int(fn["firsLevel"]);
+  first_level_ = int(fn["firstLevel"]);
   edge_threshold_ = fn["edgeThreshold"];
   patch_size_ = fn["patchSize"];
 }
@@ -454,7 +462,7 @@ void ORB::CommonParams::write(FileStorage& fs) const
 {
   fs << "scaleFactor" << scale_factor_;
   fs << "nLevels" << int(n_levels_);
-  fs << "firsLevel" << int(first_level_);
+  fs << "firstLevel" << int(first_level_);
   fs << "edgeThreshold" << int(edge_threshold_);
   fs << "patchSize" << int(patch_size_);
 }
@@ -499,9 +507,45 @@ DenseFeatureDetector::Params::Params( float _initFeatureScale, int _featureScale
 	varyXyStepWithScale(_varyXyStepWithScale), varyImgBoundWithScale(_varyImgBoundWithScale)
 {}
 
+void DenseFeatureDetector::Params::read( const FileNode& fn )
+{
+    initFeatureScale = fn["initFeatureScale"];
+    featureScaleLevels = fn["featureScaleLevels"];
+    featureScaleMul = fn["featureScaleMul"];
+
+    initXyStep = fn["initXyStep"];
+    initImgBound = fn["initImgBound"];
+
+    varyXyStepWithScale = (int)fn["varyXyStepWithScale"] != 0 ? true : false;
+    varyImgBoundWithScale = (int)fn["varyImgBoundWithScale"] != 0 ? true : false;
+}
+
+void DenseFeatureDetector::Params::write( FileStorage& fs ) const
+{
+    fs << "initFeatureScale" << initFeatureScale;
+    fs << "featureScaleLevels" << featureScaleLevels;
+    fs << "featureScaleMul" << featureScaleMul;
+
+    fs << "initXyStep" << initXyStep;
+    fs << "initImgBound" << initImgBound;
+
+    fs << "varyXyStepWithScale" << (int)varyXyStepWithScale;
+    fs << "varyImgBoundWithScale" << (int)varyImgBoundWithScale;
+}
+
 DenseFeatureDetector::DenseFeatureDetector(const DenseFeatureDetector::Params &_params) : params(_params)
 {}
 
+void DenseFeatureDetector::read( const FileNode &fn )
+{
+    params.read(fn);
+}
+
+void DenseFeatureDetector::write( FileStorage &fs ) const
+{
+    params.write(fs);
+}
+
 void DenseFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
 {
     float curScale = params.initFeatureScale;
@@ -575,8 +619,9 @@ void GridAdaptedFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>&
             vector<KeyPoint> sub_keypoints;
             detector->detect( sub_image, sub_keypoints, sub_mask );
             keepStrongest( maxPerCell, sub_keypoints );
-            for( std::vector<cv::KeyPoint>::iterator it = sub_keypoints.begin(), end = sub_keypoints.end();
-                 it != end; ++it )
+            std::vector<cv::KeyPoint>::iterator it = sub_keypoints.begin(),
+                                                end = sub_keypoints.end();
+            for( ; it != end; ++it )
             {
                 it->pt.x += col_range.start;
                 it->pt.y += row_range.start;
@@ -602,12 +647,25 @@ bool PyramidAdaptedFeatureDetector::empty() const
 void PyramidAdaptedFeatureDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask ) const
 {
     Mat src = image;
+    Mat src_mask = mask;
+
+    Mat dilated_mask;
+    if( !mask.empty() )
+    {
+        dilate( mask, dilated_mask, Mat() );
+        Mat mask255( mask.size(), CV_8UC1, Scalar(0) );
+        mask255.setTo( Scalar(255), dilated_mask != 0 );
+        dilated_mask = mask255;
+    }
+
     for( int l = 0, multiplier = 1; l <= maxLevel; ++l, multiplier *= 2 )
     {
         // Detect on current level of the pyramid
         vector<KeyPoint> new_pts;
-        detector->detect( src, new_pts, mask );
-        for( vector<KeyPoint>::iterator it = new_pts.begin(), end = new_pts.end(); it != end; ++it)
+        detector->detect( src, new_pts, src_mask );
+        vector<KeyPoint>::iterator it = new_pts.begin(),
+                                   end = new_pts.end();
+        for( ; it != end; ++it)
         {
             it->pt.x *= multiplier;
             it->pt.y *= multiplier;
@@ -620,10 +678,16 @@ void PyramidAdaptedFeatureDetector::detectImpl( const Mat& image, vector<KeyPoin
         if( l < maxLevel )
         {
             Mat dst;
-            pyrDown(src, dst);
+            pyrDown( src, dst );
             src = dst;
+
+            if( !mask.empty() )
+                resize( dilated_mask, src_mask, src.size(), 0, 0, CV_INTER_AREA );
         }
     }
+
+    if( !mask.empty() )
+        KeyPointsFilter::runByPixelsMask( keypoints, mask );
 }
 
 }
diff --git a/modules/features2d/src/draw.cpp b/modules/features2d/src/draw.cpp
index 45ee5862f0..26d96d71e9 100755
--- a/modules/features2d/src/draw.cpp
+++ b/modules/features2d/src/draw.cpp
@@ -54,6 +54,7 @@ namespace cv
  */
 static inline void _drawKeypoint( Mat& img, const KeyPoint& p, const Scalar& color, int flags )
 {
+    CV_Assert( !img.empty() );
     Point center( cvRound(p.pt.x * draw_multiplier), cvRound(p.pt.y * draw_multiplier) );
 
     if( flags & DrawMatchesFlags::DRAW_RICH_KEYPOINTS )
@@ -111,10 +112,13 @@ void drawKeypoints( const Mat& image, const vector<KeyPoint>& keypoints, Mat& ou
     RNG& rng=theRNG();
     bool isRandColor = _color == Scalar::all(-1);
 
-    for( vector<KeyPoint>::const_iterator i = keypoints.begin(), ie = keypoints.end(); i != ie; ++i )
+    CV_Assert( !outImage.empty() );
+    vector<KeyPoint>::const_iterator it = keypoints.begin(),
+                                     end = keypoints.end();
+    for( ; it != end; ++it )
     {
         Scalar color = isRandColor ? Scalar(rng(256), rng(256), rng(256)) : _color;
-        _drawKeypoint( outImage, *i, color, flags );
+        _drawKeypoint( outImage, *it, color, flags );
     }
 }
 
diff --git a/modules/features2d/src/evaluation.cpp b/modules/features2d/src/evaluation.cpp
index 0cf53a8033..ba1a76b818 100644
--- a/modules/features2d/src/evaluation.cpp
+++ b/modules/features2d/src/evaluation.cpp
@@ -388,7 +388,8 @@ static void calculateRepeatability( const Mat& img1, const Mat& img2, const Mat&
         thresholdedOverlapMask->create( (int)keypoints1.size(), (int)keypoints2t.size(), CV_8UC1 );
         thresholdedOverlapMask->setTo( Scalar::all(0) );
     }
-    size_t minCount = min( keypoints1.size(), keypoints2t.size() );
+	size_t size1 = keypoints1.size(), size2 = keypoints2t.size();
+    size_t minCount = MIN( size1, size2 );
 
     // calculate overlap errors
     vector<SIdx> overlaps;
diff --git a/modules/features2d/src/generated_16.i b/modules/features2d/src/generated_16.i
index c6e7597cd2..b85bf06d9e 100644
--- a/modules/features2d/src/generated_16.i
+++ b/modules/features2d/src/generated_16.i
@@ -1,19 +1,19 @@
 // Code generated with '$ scripts/generate_code.py src/test_pairs.txt 16'
 #define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
-    desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
-    desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
-    desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
-    desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
-    desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
-    desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
-    desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
-    desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
-    desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
-    desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
-    desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
-    desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
-    desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
-    desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
-    desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
-    desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
+    desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
+    desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
+    desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
+    desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
+    desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
+    desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
+    desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
+    desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
+    desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
+    desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
+    desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
+    desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
+    desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
+    desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
+    desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
+    desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
 #undef SMOOTHED
diff --git a/modules/features2d/src/generated_32.i b/modules/features2d/src/generated_32.i
index 0f13acfb23..19952d2f75 100644
--- a/modules/features2d/src/generated_32.i
+++ b/modules/features2d/src/generated_32.i
@@ -1,35 +1,35 @@
 // Code generated with '$ scripts/generate_code.py src/test_pairs.txt 32'
 #define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
-    desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
-    desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
-    desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
-    desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
-    desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
-    desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
-    desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
-    desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
-    desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
-    desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
-    desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
-    desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
-    desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
-    desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
-    desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
-    desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
-    desc[16] = ((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0) ;
-    desc[17] = ((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0) ;
-    desc[18] = ((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0) ;
-    desc[19] = ((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0) ;
-    desc[20] = ((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0) ;
-    desc[21] = ((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0) ;
-    desc[22] = ((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0) ;
-    desc[23] = ((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0) ;
-    desc[24] = ((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0) ;
-    desc[25] = ((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0) ;
-    desc[26] = ((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0) ;
-    desc[27] = ((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0) ;
-    desc[28] = ((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0) ;
-    desc[29] = ((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0) ;
-    desc[30] = ((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0) ;
-    desc[31] = ((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0) ;
+    desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
+    desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
+    desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
+    desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
+    desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
+    desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
+    desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
+    desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
+    desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
+    desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
+    desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
+    desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
+    desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
+    desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
+    desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
+    desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
+    desc[16] = (uchar)(((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0));
+    desc[17] = (uchar)(((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0));
+    desc[18] = (uchar)(((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0));
+    desc[19] = (uchar)(((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0));
+    desc[20] = (uchar)(((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0));
+    desc[21] = (uchar)(((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0));
+    desc[22] = (uchar)(((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0));
+    desc[23] = (uchar)(((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0));
+    desc[24] = (uchar)(((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0));
+    desc[25] = (uchar)(((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0));
+    desc[26] = (uchar)(((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0));
+    desc[27] = (uchar)(((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0));
+    desc[28] = (uchar)(((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0));
+    desc[29] = (uchar)(((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0));
+    desc[30] = (uchar)(((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0));
+    desc[31] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0));
 #undef SMOOTHED
diff --git a/modules/features2d/src/generated_64.i b/modules/features2d/src/generated_64.i
index 3b47de7624..2262e2d412 100644
--- a/modules/features2d/src/generated_64.i
+++ b/modules/features2d/src/generated_64.i
@@ -1,67 +1,67 @@
 // Code generated with '$ scripts/generate_code.py src/test_pairs.txt 64'
 #define SMOOTHED(y,x) smoothedSum(sum, pt, y, x)
-    desc[0] = ((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0) ;
-    desc[1] = ((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0) ;
-    desc[2] = ((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0) ;
-    desc[3] = ((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0) ;
-    desc[4] = ((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0) ;
-    desc[5] = ((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0) ;
-    desc[6] = ((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0) ;
-    desc[7] = ((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0) ;
-    desc[8] = ((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0) ;
-    desc[9] = ((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0) ;
-    desc[10] = ((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0) ;
-    desc[11] = ((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0) ;
-    desc[12] = ((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0) ;
-    desc[13] = ((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0) ;
-    desc[14] = ((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0) ;
-    desc[15] = ((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0) ;
-    desc[16] = ((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0) ;
-    desc[17] = ((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0) ;
-    desc[18] = ((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0) ;
-    desc[19] = ((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0) ;
-    desc[20] = ((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0) ;
-    desc[21] = ((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0) ;
-    desc[22] = ((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0) ;
-    desc[23] = ((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0) ;
-    desc[24] = ((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0) ;
-    desc[25] = ((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0) ;
-    desc[26] = ((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0) ;
-    desc[27] = ((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0) ;
-    desc[28] = ((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0) ;
-    desc[29] = ((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0) ;
-    desc[30] = ((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0) ;
-    desc[31] = ((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0) ;
-    desc[32] = ((SMOOTHED(16, 12) < SMOOTHED(0, 19)) << 7) + ((SMOOTHED(4, 3) < SMOOTHED(6, 0)) << 6) + ((SMOOTHED(-2, -1) < SMOOTHED(2, 17)) << 5) + ((SMOOTHED(8, 1) < SMOOTHED(3, 1)) << 4) + ((SMOOTHED(-12, -1) < SMOOTHED(-11, 0)) << 3) + ((SMOOTHED(-11, 2) < SMOOTHED(7, 9)) << 2) + ((SMOOTHED(-1, 3) < SMOOTHED(-19, 4)) << 1) + ((SMOOTHED(-1, -11) < SMOOTHED(-1, 3)) << 0) ;
-    desc[33] = ((SMOOTHED(1, -10) < SMOOTHED(-10, -4)) << 7) + ((SMOOTHED(-2, 3) < SMOOTHED(6, 11)) << 6) + ((SMOOTHED(3, 7) < SMOOTHED(-9, -8)) << 5) + ((SMOOTHED(24, -14) < SMOOTHED(-2, -10)) << 4) + ((SMOOTHED(-3, -3) < SMOOTHED(-18, -6)) << 3) + ((SMOOTHED(-13, -10) < SMOOTHED(-7, -1)) << 2) + ((SMOOTHED(2, -7) < SMOOTHED(9, -6)) << 1) + ((SMOOTHED(2, -4) < SMOOTHED(6, -13)) << 0) ;
-    desc[34] = ((SMOOTHED(4, -4) < SMOOTHED(-2, 3)) << 7) + ((SMOOTHED(-4, 2) < SMOOTHED(9, 13)) << 6) + ((SMOOTHED(-11, 5) < SMOOTHED(-6, -11)) << 5) + ((SMOOTHED(4, -2) < SMOOTHED(11, -9)) << 4) + ((SMOOTHED(-19, 0) < SMOOTHED(-23, -5)) << 3) + ((SMOOTHED(-5, -7) < SMOOTHED(-3, -6)) << 2) + ((SMOOTHED(-6, -4) < SMOOTHED(12, 14)) << 1) + ((SMOOTHED(12, -11) < SMOOTHED(-8, -16)) << 0) ;
-    desc[35] = ((SMOOTHED(-21, 15) < SMOOTHED(-12, 6)) << 7) + ((SMOOTHED(-2, -1) < SMOOTHED(-8, 16)) << 6) + ((SMOOTHED(6, -1) < SMOOTHED(-8, -2)) << 5) + ((SMOOTHED(1, -1) < SMOOTHED(-9, 8)) << 4) + ((SMOOTHED(3, -4) < SMOOTHED(-2, -2)) << 3) + ((SMOOTHED(-7, 0) < SMOOTHED(4, -8)) << 2) + ((SMOOTHED(11, -11) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(2, 3) < SMOOTHED(11, 7)) << 0) ;
-    desc[36] = ((SMOOTHED(-7, -4) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(3, -7) < SMOOTHED(-5, 0)) << 6) + ((SMOOTHED(3, -7) < SMOOTHED(-10, -5)) << 5) + ((SMOOTHED(-3, -1) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(0, 8) < SMOOTHED(5, 1)) << 3) + ((SMOOTHED(9, 0) < SMOOTHED(1, 16)) << 2) + ((SMOOTHED(8, 4) < SMOOTHED(-11, -3)) << 1) + ((SMOOTHED(-15, 9) < SMOOTHED(8, 17)) << 0) ;
-    desc[37] = ((SMOOTHED(0, 2) < SMOOTHED(-9, 17)) << 7) + ((SMOOTHED(-6, -11) < SMOOTHED(-10, -3)) << 6) + ((SMOOTHED(1, 1) < SMOOTHED(15, -8)) << 5) + ((SMOOTHED(-12, -13) < SMOOTHED(-2, 4)) << 4) + ((SMOOTHED(-6, 4) < SMOOTHED(-6, -10)) << 3) + ((SMOOTHED(5, -7) < SMOOTHED(7, -5)) << 2) + ((SMOOTHED(10, 6) < SMOOTHED(8, 9)) << 1) + ((SMOOTHED(-5, 7) < SMOOTHED(-18, -3)) << 0) ;
-    desc[38] = ((SMOOTHED(-6, 3) < SMOOTHED(5, 4)) << 7) + ((SMOOTHED(-10, -13) < SMOOTHED(-5, -3)) << 6) + ((SMOOTHED(-11, 2) < SMOOTHED(-16, 0)) << 5) + ((SMOOTHED(7, -21) < SMOOTHED(-5, -13)) << 4) + ((SMOOTHED(-14, -14) < SMOOTHED(-4, -4)) << 3) + ((SMOOTHED(4, 9) < SMOOTHED(7, -3)) << 2) + ((SMOOTHED(4, 11) < SMOOTHED(10, -4)) << 1) + ((SMOOTHED(6, 17) < SMOOTHED(9, 17)) << 0) ;
-    desc[39] = ((SMOOTHED(-10, 8) < SMOOTHED(0, -11)) << 7) + ((SMOOTHED(-6, -16) < SMOOTHED(-6, 8)) << 6) + ((SMOOTHED(-13, 5) < SMOOTHED(10, -5)) << 5) + ((SMOOTHED(3, 2) < SMOOTHED(12, 16)) << 4) + ((SMOOTHED(13, -8) < SMOOTHED(0, -6)) << 3) + ((SMOOTHED(10, 0) < SMOOTHED(4, -11)) << 2) + ((SMOOTHED(8, 5) < SMOOTHED(10, -2)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(-13, 3)) << 0) ;
-    desc[40] = ((SMOOTHED(2, 4) < SMOOTHED(-7, -3)) << 7) + ((SMOOTHED(-14, -2) < SMOOTHED(-11, 16)) << 6) + ((SMOOTHED(11, -6) < SMOOTHED(7, 6)) << 5) + ((SMOOTHED(-3, 15) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(-3, 8) < SMOOTHED(12, -12)) << 3) + ((SMOOTHED(-13, 6) < SMOOTHED(-14, 7)) << 2) + ((SMOOTHED(-11, -5) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(7, -6) < SMOOTHED(6, 3)) << 0) ;
-    desc[41] = ((SMOOTHED(-4, 10) < SMOOTHED(5, 1)) << 7) + ((SMOOTHED(9, 16) < SMOOTHED(10, 13)) << 6) + ((SMOOTHED(-17, 10) < SMOOTHED(2, 8)) << 5) + ((SMOOTHED(-5, 1) < SMOOTHED(4, -4)) << 4) + ((SMOOTHED(-14, 8) < SMOOTHED(-5, 2)) << 3) + ((SMOOTHED(4, -9) < SMOOTHED(-6, -3)) << 2) + ((SMOOTHED(3, -7) < SMOOTHED(-10, 0)) << 1) + ((SMOOTHED(-2, -8) < SMOOTHED(-10, 4)) << 0) ;
-    desc[42] = ((SMOOTHED(-8, 5) < SMOOTHED(-9, 24)) << 7) + ((SMOOTHED(2, -8) < SMOOTHED(8, -9)) << 6) + ((SMOOTHED(-4, 17) < SMOOTHED(-5, 2)) << 5) + ((SMOOTHED(14, 0) < SMOOTHED(-9, 9)) << 4) + ((SMOOTHED(11, 15) < SMOOTHED(-6, 5)) << 3) + ((SMOOTHED(-8, 1) < SMOOTHED(-3, 4)) << 2) + ((SMOOTHED(9, -21) < SMOOTHED(10, 2)) << 1) + ((SMOOTHED(2, -1) < SMOOTHED(4, 11)) << 0) ;
-    desc[43] = ((SMOOTHED(24, 3) < SMOOTHED(2, -2)) << 7) + ((SMOOTHED(-8, 17) < SMOOTHED(-14, -10)) << 6) + ((SMOOTHED(6, 5) < SMOOTHED(-13, 7)) << 5) + ((SMOOTHED(11, 10) < SMOOTHED(0, -1)) << 4) + ((SMOOTHED(4, 6) < SMOOTHED(-10, 6)) << 3) + ((SMOOTHED(-12, -2) < SMOOTHED(5, 6)) << 2) + ((SMOOTHED(3, -1) < SMOOTHED(8, -15)) << 1) + ((SMOOTHED(1, -4) < SMOOTHED(-7, 11)) << 0) ;
-    desc[44] = ((SMOOTHED(1, 11) < SMOOTHED(5, 0)) << 7) + ((SMOOTHED(6, -12) < SMOOTHED(10, 1)) << 6) + ((SMOOTHED(-3, -2) < SMOOTHED(-1, 4)) << 5) + ((SMOOTHED(-2, -11) < SMOOTHED(-1, 12)) << 4) + ((SMOOTHED(7, -8) < SMOOTHED(-20, -18)) << 3) + ((SMOOTHED(2, 0) < SMOOTHED(-9, 2)) << 2) + ((SMOOTHED(-13, -1) < SMOOTHED(-16, 2)) << 1) + ((SMOOTHED(3, -1) < SMOOTHED(-5, -17)) << 0) ;
-    desc[45] = ((SMOOTHED(15, 8) < SMOOTHED(3, -14)) << 7) + ((SMOOTHED(-13, -12) < SMOOTHED(6, 15)) << 6) + ((SMOOTHED(2, -8) < SMOOTHED(2, 6)) << 5) + ((SMOOTHED(6, 22) < SMOOTHED(-3, -23)) << 4) + ((SMOOTHED(-2, -7) < SMOOTHED(-6, 0)) << 3) + ((SMOOTHED(13, -10) < SMOOTHED(-6, 6)) << 2) + ((SMOOTHED(6, 7) < SMOOTHED(-10, 12)) << 1) + ((SMOOTHED(-6, 7) < SMOOTHED(-2, 11)) << 0) ;
-    desc[46] = ((SMOOTHED(0, -22) < SMOOTHED(-2, -17)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-11, -14)) << 6) + ((SMOOTHED(-2, -8) < SMOOTHED(7, 12)) << 5) + ((SMOOTHED(12, -5) < SMOOTHED(7, -13)) << 4) + ((SMOOTHED(2, -2) < SMOOTHED(-7, 6)) << 3) + ((SMOOTHED(0, 8) < SMOOTHED(-3, 23)) << 2) + ((SMOOTHED(6, 12) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(-21, -10) < SMOOTHED(10, 8)) << 0) ;
-    desc[47] = ((SMOOTHED(-3, 0) < SMOOTHED(7, 15)) << 7) + ((SMOOTHED(7, -6) < SMOOTHED(-5, -12)) << 6) + ((SMOOTHED(-21, -10) < SMOOTHED(12, -11)) << 5) + ((SMOOTHED(-5, -11) < SMOOTHED(8, -11)) << 4) + ((SMOOTHED(5, 0) < SMOOTHED(-11, -1)) << 3) + ((SMOOTHED(8, -9) < SMOOTHED(7, -1)) << 2) + ((SMOOTHED(11, -23) < SMOOTHED(21, -5)) << 1) + ((SMOOTHED(0, -5) < SMOOTHED(-8, 6)) << 0) ;
-    desc[48] = ((SMOOTHED(-6, 8) < SMOOTHED(8, 12)) << 7) + ((SMOOTHED(-7, 5) < SMOOTHED(3, -2)) << 6) + ((SMOOTHED(-5, -20) < SMOOTHED(-12, 9)) << 5) + ((SMOOTHED(-6, 12) < SMOOTHED(-11, 3)) << 4) + ((SMOOTHED(4, 5) < SMOOTHED(13, 11)) << 3) + ((SMOOTHED(2, 12) < SMOOTHED(13, -12)) << 2) + ((SMOOTHED(-4, -13) < SMOOTHED(4, 7)) << 1) + ((SMOOTHED(0, 15) < SMOOTHED(-3, -16)) << 0) ;
-    desc[49] = ((SMOOTHED(-3, 2) < SMOOTHED(-2, 14)) << 7) + ((SMOOTHED(4, -14) < SMOOTHED(16, -11)) << 6) + ((SMOOTHED(-13, 3) < SMOOTHED(23, 10)) << 5) + ((SMOOTHED(9, -19) < SMOOTHED(2, 5)) << 4) + ((SMOOTHED(5, 3) < SMOOTHED(14, -7)) << 3) + ((SMOOTHED(19, -13) < SMOOTHED(-11, 15)) << 2) + ((SMOOTHED(14, 0) < SMOOTHED(-2, -5)) << 1) + ((SMOOTHED(11, -4) < SMOOTHED(0, -6)) << 0) ;
-    desc[50] = ((SMOOTHED(-2, 5) < SMOOTHED(-13, -8)) << 7) + ((SMOOTHED(-11, -15) < SMOOTHED(-7, -17)) << 6) + ((SMOOTHED(1, 3) < SMOOTHED(-10, -8)) << 5) + ((SMOOTHED(-13, -10) < SMOOTHED(7, -12)) << 4) + ((SMOOTHED(0, -13) < SMOOTHED(23, -6)) << 3) + ((SMOOTHED(2, -17) < SMOOTHED(-7, -3)) << 2) + ((SMOOTHED(1, 3) < SMOOTHED(4, -10)) << 1) + ((SMOOTHED(13, 4) < SMOOTHED(14, -6)) << 0) ;
-    desc[51] = ((SMOOTHED(-19, -2) < SMOOTHED(-1, 5)) << 7) + ((SMOOTHED(9, -8) < SMOOTHED(10, -5)) << 6) + ((SMOOTHED(7, -1) < SMOOTHED(5, 7)) << 5) + ((SMOOTHED(9, -10) < SMOOTHED(19, 0)) << 4) + ((SMOOTHED(7, 5) < SMOOTHED(-4, -7)) << 3) + ((SMOOTHED(-11, 1) < SMOOTHED(-1, -11)) << 2) + ((SMOOTHED(2, -1) < SMOOTHED(-4, 11)) << 1) + ((SMOOTHED(-1, 7) < SMOOTHED(2, -2)) << 0) ;
-    desc[52] = ((SMOOTHED(1, -20) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(-4, -18) < SMOOTHED(8, -18)) << 6) + ((SMOOTHED(-16, -2) < SMOOTHED(7, -6)) << 5) + ((SMOOTHED(-3, -6) < SMOOTHED(-1, -4)) << 4) + ((SMOOTHED(0, -16) < SMOOTHED(24, -5)) << 3) + ((SMOOTHED(-4, -2) < SMOOTHED(-1, 9)) << 2) + ((SMOOTHED(-8, 2) < SMOOTHED(-6, 15)) << 1) + ((SMOOTHED(11, 4) < SMOOTHED(0, -3)) << 0) ;
-    desc[53] = ((SMOOTHED(7, 6) < SMOOTHED(2, -10)) << 7) + ((SMOOTHED(-7, -9) < SMOOTHED(12, -6)) << 6) + ((SMOOTHED(24, 15) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(15, -9) < SMOOTHED(-3, -15)) << 4) + ((SMOOTHED(17, -5) < SMOOTHED(11, -10)) << 3) + ((SMOOTHED(-2, 13) < SMOOTHED(-15, 4)) << 2) + ((SMOOTHED(-2, -1) < SMOOTHED(4, -23)) << 1) + ((SMOOTHED(-16, 3) < SMOOTHED(-7, -14)) << 0) ;
-    desc[54] = ((SMOOTHED(-3, -5) < SMOOTHED(-10, -9)) << 7) + ((SMOOTHED(-5, 3) < SMOOTHED(-2, -1)) << 6) + ((SMOOTHED(-1, 4) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(12, 9) < SMOOTHED(9, -14)) << 4) + ((SMOOTHED(-9, 17) < SMOOTHED(-3, 0)) << 3) + ((SMOOTHED(5, 4) < SMOOTHED(13, -6)) << 2) + ((SMOOTHED(-1, -8) < SMOOTHED(19, 10)) << 1) + ((SMOOTHED(8, -5) < SMOOTHED(-15, 2)) << 0) ;
-    desc[55] = ((SMOOTHED(-12, -9) < SMOOTHED(-4, -5)) << 7) + ((SMOOTHED(12, 0) < SMOOTHED(24, 4)) << 6) + ((SMOOTHED(8, -2) < SMOOTHED(14, 4)) << 5) + ((SMOOTHED(8, -4) < SMOOTHED(-7, 16)) << 4) + ((SMOOTHED(5, -1) < SMOOTHED(-8, -4)) << 3) + ((SMOOTHED(-2, 18) < SMOOTHED(-5, 17)) << 2) + ((SMOOTHED(8, -2) < SMOOTHED(-9, -2)) << 1) + ((SMOOTHED(3, -7) < SMOOTHED(1, -6)) << 0) ;
-    desc[56] = ((SMOOTHED(-5, -22) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, -10) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(-3, -13) < SMOOTHED(3, 9)) << 5) + ((SMOOTHED(-4, -1) < SMOOTHED(-1, 0)) << 4) + ((SMOOTHED(-7, -21) < SMOOTHED(12, -19)) << 3) + ((SMOOTHED(-8, 8) < SMOOTHED(24, 8)) << 2) + ((SMOOTHED(12, -6) < SMOOTHED(-2, 3)) << 1) + ((SMOOTHED(-5, -11) < SMOOTHED(-22, -4)) << 0) ;
-    desc[57] = ((SMOOTHED(-3, 5) < SMOOTHED(-4, 4)) << 7) + ((SMOOTHED(-16, 24) < SMOOTHED(7, -9)) << 6) + ((SMOOTHED(-10, 23) < SMOOTHED(-9, 18)) << 5) + ((SMOOTHED(1, 12) < SMOOTHED(17, 21)) << 4) + ((SMOOTHED(24, -6) < SMOOTHED(-3, -11)) << 3) + ((SMOOTHED(-7, 17) < SMOOTHED(1, -6)) << 2) + ((SMOOTHED(4, 4) < SMOOTHED(2, -7)) << 1) + ((SMOOTHED(14, 6) < SMOOTHED(-12, 3)) << 0) ;
-    desc[58] = ((SMOOTHED(-6, 0) < SMOOTHED(-16, 13)) << 7) + ((SMOOTHED(-10, 5) < SMOOTHED(7, 12)) << 6) + ((SMOOTHED(5, 2) < SMOOTHED(6, -3)) << 5) + ((SMOOTHED(7, 0) < SMOOTHED(-23, 1)) << 4) + ((SMOOTHED(15, -5) < SMOOTHED(1, 14)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(6, 6)) << 2) + ((SMOOTHED(6, -9) < SMOOTHED(-9, 12)) << 1) + ((SMOOTHED(4, -2) < SMOOTHED(-4, 7)) << 0) ;
-    desc[59] = ((SMOOTHED(-4, -5) < SMOOTHED(4, 4)) << 7) + ((SMOOTHED(-13, 0) < SMOOTHED(6, -10)) << 6) + ((SMOOTHED(2, -12) < SMOOTHED(-6, -3)) << 5) + ((SMOOTHED(16, 0) < SMOOTHED(-3, 3)) << 4) + ((SMOOTHED(5, -14) < SMOOTHED(6, 11)) << 3) + ((SMOOTHED(5, 11) < SMOOTHED(0, -13)) << 2) + ((SMOOTHED(7, 5) < SMOOTHED(-1, -5)) << 1) + ((SMOOTHED(12, 4) < SMOOTHED(6, 10)) << 0) ;
-    desc[60] = ((SMOOTHED(-10, 4) < SMOOTHED(-1, -11)) << 7) + ((SMOOTHED(4, 10) < SMOOTHED(-14, 5)) << 6) + ((SMOOTHED(11, -14) < SMOOTHED(-13, 0)) << 5) + ((SMOOTHED(2, 8) < SMOOTHED(12, 24)) << 4) + ((SMOOTHED(-1, 3) < SMOOTHED(-1, 2)) << 3) + ((SMOOTHED(9, -14) < SMOOTHED(-23, 3)) << 2) + ((SMOOTHED(-8, -6) < SMOOTHED(0, 9)) << 1) + ((SMOOTHED(-15, 14) < SMOOTHED(10, -10)) << 0) ;
-    desc[61] = ((SMOOTHED(-10, -6) < SMOOTHED(-7, -5)) << 7) + ((SMOOTHED(11, 5) < SMOOTHED(-3, -15)) << 6) + ((SMOOTHED(1, 0) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(-11, -6) < SMOOTHED(-4, -18)) << 4) + ((SMOOTHED(9, 0) < SMOOTHED(22, -4)) << 3) + ((SMOOTHED(-5, -1) < SMOOTHED(-9, 4)) << 2) + ((SMOOTHED(-20, 2) < SMOOTHED(1, 6)) << 1) + ((SMOOTHED(1, 2) < SMOOTHED(-9, -12)) << 0) ;
-    desc[62] = ((SMOOTHED(5, 15) < SMOOTHED(4, -6)) << 7) + ((SMOOTHED(19, 4) < SMOOTHED(4, 11)) << 6) + ((SMOOTHED(17, -4) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(-8, -12) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(11, 9) < SMOOTHED(8, 1)) << 3) + ((SMOOTHED(9, 22) < SMOOTHED(-15, 15)) << 2) + ((SMOOTHED(-7, -7) < SMOOTHED(1, -23)) << 1) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 2)) << 0) ;
-    desc[63] = ((SMOOTHED(3, -5) < SMOOTHED(11, -11)) << 7) + ((SMOOTHED(3, -18) < SMOOTHED(14, -5)) << 6) + ((SMOOTHED(-20, 7) < SMOOTHED(-10, -23)) << 5) + ((SMOOTHED(-2, -5) < SMOOTHED(6, 0)) << 4) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 3) + ((SMOOTHED(-6, -1) < SMOOTHED(14, -2)) << 2) + ((SMOOTHED(-12, -16) < SMOOTHED(15, 6)) << 1) + ((SMOOTHED(-12, -2) < SMOOTHED(3, -19)) << 0) ;
+    desc[0] = (uchar)(((SMOOTHED(-2, -1) < SMOOTHED(7, -1)) << 7) + ((SMOOTHED(-14, -1) < SMOOTHED(-3, 3)) << 6) + ((SMOOTHED(1, -2) < SMOOTHED(11, 2)) << 5) + ((SMOOTHED(1, 6) < SMOOTHED(-10, -7)) << 4) + ((SMOOTHED(13, 2) < SMOOTHED(-1, 0)) << 3) + ((SMOOTHED(-14, 5) < SMOOTHED(5, -3)) << 2) + ((SMOOTHED(-2, 8) < SMOOTHED(2, 4)) << 1) + ((SMOOTHED(-11, 8) < SMOOTHED(-15, 5)) << 0));
+    desc[1] = (uchar)(((SMOOTHED(-6, -23) < SMOOTHED(8, -9)) << 7) + ((SMOOTHED(-12, 6) < SMOOTHED(-10, 8)) << 6) + ((SMOOTHED(-3, -1) < SMOOTHED(8, 1)) << 5) + ((SMOOTHED(3, 6) < SMOOTHED(5, 6)) << 4) + ((SMOOTHED(-7, -6) < SMOOTHED(5, -5)) << 3) + ((SMOOTHED(22, -2) < SMOOTHED(-11, -8)) << 2) + ((SMOOTHED(14, 7) < SMOOTHED(8, 5)) << 1) + ((SMOOTHED(-1, 14) < SMOOTHED(-5, -14)) << 0));
+    desc[2] = (uchar)(((SMOOTHED(-14, 9) < SMOOTHED(2, 0)) << 7) + ((SMOOTHED(7, -3) < SMOOTHED(22, 6)) << 6) + ((SMOOTHED(-6, 6) < SMOOTHED(-8, -5)) << 5) + ((SMOOTHED(-5, 9) < SMOOTHED(7, -1)) << 4) + ((SMOOTHED(-3, -7) < SMOOTHED(-10, -18)) << 3) + ((SMOOTHED(4, -5) < SMOOTHED(0, 11)) << 2) + ((SMOOTHED(2, 3) < SMOOTHED(9, 10)) << 1) + ((SMOOTHED(-10, 3) < SMOOTHED(4, 9)) << 0));
+    desc[3] = (uchar)(((SMOOTHED(0, 12) < SMOOTHED(-3, 19)) << 7) + ((SMOOTHED(1, 15) < SMOOTHED(-11, -5)) << 6) + ((SMOOTHED(14, -1) < SMOOTHED(7, 8)) << 5) + ((SMOOTHED(7, -23) < SMOOTHED(-5, 5)) << 4) + ((SMOOTHED(0, -6) < SMOOTHED(-10, 17)) << 3) + ((SMOOTHED(13, -4) < SMOOTHED(-3, -4)) << 2) + ((SMOOTHED(-12, 1) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(0, 8) < SMOOTHED(3, 22)) << 0));
+    desc[4] = (uchar)(((SMOOTHED(-13, 13) < SMOOTHED(3, -1)) << 7) + ((SMOOTHED(-16, 17) < SMOOTHED(6, 10)) << 6) + ((SMOOTHED(7, 15) < SMOOTHED(-5, 0)) << 5) + ((SMOOTHED(2, -12) < SMOOTHED(19, -2)) << 4) + ((SMOOTHED(3, -6) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(8, 3) < SMOOTHED(0, 14)) << 2) + ((SMOOTHED(4, -11) < SMOOTHED(5, 5)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(7, 1)) << 0));
+    desc[5] = (uchar)(((SMOOTHED(6, 12) < SMOOTHED(21, 3)) << 7) + ((SMOOTHED(-3, 2) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(5, 1) < SMOOTHED(-5, 11)) << 5) + ((SMOOTHED(3, -17) < SMOOTHED(-6, 2)) << 4) + ((SMOOTHED(6, 8) < SMOOTHED(5, -10)) << 3) + ((SMOOTHED(-14, -2) < SMOOTHED(0, 4)) << 2) + ((SMOOTHED(5, -7) < SMOOTHED(-6, 5)) << 1) + ((SMOOTHED(10, 4) < SMOOTHED(4, -7)) << 0));
+    desc[6] = (uchar)(((SMOOTHED(22, 0) < SMOOTHED(7, -18)) << 7) + ((SMOOTHED(-1, -3) < SMOOTHED(0, 18)) << 6) + ((SMOOTHED(-4, 22) < SMOOTHED(-5, 3)) << 5) + ((SMOOTHED(1, -7) < SMOOTHED(2, -3)) << 4) + ((SMOOTHED(19, -20) < SMOOTHED(17, -2)) << 3) + ((SMOOTHED(3, -10) < SMOOTHED(-8, 24)) << 2) + ((SMOOTHED(-5, -14) < SMOOTHED(7, 5)) << 1) + ((SMOOTHED(-2, 12) < SMOOTHED(-4, -15)) << 0));
+    desc[7] = (uchar)(((SMOOTHED(4, 12) < SMOOTHED(0, -19)) << 7) + ((SMOOTHED(20, 13) < SMOOTHED(3, 5)) << 6) + ((SMOOTHED(-8, -12) < SMOOTHED(5, 0)) << 5) + ((SMOOTHED(-5, 6) < SMOOTHED(-7, -11)) << 4) + ((SMOOTHED(6, -11) < SMOOTHED(-3, -22)) << 3) + ((SMOOTHED(15, 4) < SMOOTHED(10, 1)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(15, -6)) << 1) + ((SMOOTHED(5, 10) < SMOOTHED(0, 24)) << 0));
+    desc[8] = (uchar)(((SMOOTHED(3, 6) < SMOOTHED(22, -2)) << 7) + ((SMOOTHED(-13, 14) < SMOOTHED(4, -4)) << 6) + ((SMOOTHED(-13, 8) < SMOOTHED(-18, -22)) << 5) + ((SMOOTHED(-1, -1) < SMOOTHED(-7, 3)) << 4) + ((SMOOTHED(-19, -12) < SMOOTHED(4, 3)) << 3) + ((SMOOTHED(8, 10) < SMOOTHED(13, -2)) << 2) + ((SMOOTHED(-6, -1) < SMOOTHED(-6, -5)) << 1) + ((SMOOTHED(2, -21) < SMOOTHED(-3, 2)) << 0));
+    desc[9] = (uchar)(((SMOOTHED(4, -7) < SMOOTHED(0, 16)) << 7) + ((SMOOTHED(-6, -5) < SMOOTHED(-12, -1)) << 6) + ((SMOOTHED(1, -1) < SMOOTHED(9, 18)) << 5) + ((SMOOTHED(-7, 10) < SMOOTHED(-11, 6)) << 4) + ((SMOOTHED(4, 3) < SMOOTHED(19, -7)) << 3) + ((SMOOTHED(-18, 5) < SMOOTHED(-4, 5)) << 2) + ((SMOOTHED(4, 0) < SMOOTHED(-20, 4)) << 1) + ((SMOOTHED(7, -11) < SMOOTHED(18, 12)) << 0));
+    desc[10] = (uchar)(((SMOOTHED(-20, 17) < SMOOTHED(-18, 7)) << 7) + ((SMOOTHED(2, 15) < SMOOTHED(19, -11)) << 6) + ((SMOOTHED(-18, 6) < SMOOTHED(-7, 3)) << 5) + ((SMOOTHED(-4, 1) < SMOOTHED(-14, 13)) << 4) + ((SMOOTHED(17, 3) < SMOOTHED(2, -8)) << 3) + ((SMOOTHED(-7, 2) < SMOOTHED(1, 6)) << 2) + ((SMOOTHED(17, -9) < SMOOTHED(-2, 8)) << 1) + ((SMOOTHED(-8, -6) < SMOOTHED(-1, 12)) << 0));
+    desc[11] = (uchar)(((SMOOTHED(-2, 4) < SMOOTHED(-1, 6)) << 7) + ((SMOOTHED(-2, 7) < SMOOTHED(6, 8)) << 6) + ((SMOOTHED(-8, -1) < SMOOTHED(-7, -9)) << 5) + ((SMOOTHED(8, -9) < SMOOTHED(15, 0)) << 4) + ((SMOOTHED(0, 22) < SMOOTHED(-4, -15)) << 3) + ((SMOOTHED(-14, -1) < SMOOTHED(3, -2)) << 2) + ((SMOOTHED(-7, -4) < SMOOTHED(17, -7)) << 1) + ((SMOOTHED(-8, -2) < SMOOTHED(9, -4)) << 0));
+    desc[12] = (uchar)(((SMOOTHED(5, -7) < SMOOTHED(7, 7)) << 7) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 11)) << 6) + ((SMOOTHED(11, -4) < SMOOTHED(0, 8)) << 5) + ((SMOOTHED(5, -11) < SMOOTHED(-9, -6)) << 4) + ((SMOOTHED(2, -6) < SMOOTHED(3, -20)) << 3) + ((SMOOTHED(-6, 2) < SMOOTHED(6, 10)) << 2) + ((SMOOTHED(-6, -6) < SMOOTHED(-15, 7)) << 1) + ((SMOOTHED(-6, -3) < SMOOTHED(2, 1)) << 0));
+    desc[13] = (uchar)(((SMOOTHED(11, 0) < SMOOTHED(-3, 2)) << 7) + ((SMOOTHED(7, -12) < SMOOTHED(14, 5)) << 6) + ((SMOOTHED(0, -7) < SMOOTHED(-1, -1)) << 5) + ((SMOOTHED(-16, 0) < SMOOTHED(6, 8)) << 4) + ((SMOOTHED(22, 11) < SMOOTHED(0, -3)) << 3) + ((SMOOTHED(19, 0) < SMOOTHED(5, -17)) << 2) + ((SMOOTHED(-23, -14) < SMOOTHED(-13, -19)) << 1) + ((SMOOTHED(-8, 10) < SMOOTHED(-11, -2)) << 0));
+    desc[14] = (uchar)(((SMOOTHED(-11, 6) < SMOOTHED(-10, 13)) << 7) + ((SMOOTHED(1, -7) < SMOOTHED(14, 0)) << 6) + ((SMOOTHED(-12, 1) < SMOOTHED(-5, -5)) << 5) + ((SMOOTHED(4, 7) < SMOOTHED(8, -1)) << 4) + ((SMOOTHED(-1, -5) < SMOOTHED(15, 2)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(7, -10)) << 2) + ((SMOOTHED(3, -6) < SMOOTHED(10, -18)) << 1) + ((SMOOTHED(-7, -13) < SMOOTHED(-13, 10)) << 0));
+    desc[15] = (uchar)(((SMOOTHED(1, -1) < SMOOTHED(13, -10)) << 7) + ((SMOOTHED(-19, 14) < SMOOTHED(8, -14)) << 6) + ((SMOOTHED(-4, -13) < SMOOTHED(7, 1)) << 5) + ((SMOOTHED(1, -2) < SMOOTHED(12, -7)) << 4) + ((SMOOTHED(3, -5) < SMOOTHED(1, -5)) << 3) + ((SMOOTHED(-2, -2) < SMOOTHED(8, -10)) << 2) + ((SMOOTHED(2, 14) < SMOOTHED(8, 7)) << 1) + ((SMOOTHED(3, 9) < SMOOTHED(8, 2)) << 0));
+    desc[16] = (uchar)(((SMOOTHED(-9, 1) < SMOOTHED(-18, 0)) << 7) + ((SMOOTHED(4, 0) < SMOOTHED(1, 12)) << 6) + ((SMOOTHED(0, 9) < SMOOTHED(-14, -10)) << 5) + ((SMOOTHED(-13, -9) < SMOOTHED(-2, 6)) << 4) + ((SMOOTHED(1, 5) < SMOOTHED(10, 10)) << 3) + ((SMOOTHED(-3, -6) < SMOOTHED(-16, -5)) << 2) + ((SMOOTHED(11, 6) < SMOOTHED(-5, 0)) << 1) + ((SMOOTHED(-23, 10) < SMOOTHED(1, 2)) << 0));
+    desc[17] = (uchar)(((SMOOTHED(13, -5) < SMOOTHED(-3, 9)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-13, -5)) << 6) + ((SMOOTHED(10, 13) < SMOOTHED(-11, 8)) << 5) + ((SMOOTHED(19, 20) < SMOOTHED(-9, 2)) << 4) + ((SMOOTHED(4, -8) < SMOOTHED(0, -9)) << 3) + ((SMOOTHED(-14, 10) < SMOOTHED(15, 19)) << 2) + ((SMOOTHED(-14, -12) < SMOOTHED(-10, -3)) << 1) + ((SMOOTHED(-23, -3) < SMOOTHED(17, -2)) << 0));
+    desc[18] = (uchar)(((SMOOTHED(-3, -11) < SMOOTHED(6, -14)) << 7) + ((SMOOTHED(19, -2) < SMOOTHED(-4, 2)) << 6) + ((SMOOTHED(-5, 5) < SMOOTHED(3, -13)) << 5) + ((SMOOTHED(2, -2) < SMOOTHED(-5, 4)) << 4) + ((SMOOTHED(17, 4) < SMOOTHED(17, -11)) << 3) + ((SMOOTHED(-7, -2) < SMOOTHED(1, 23)) << 2) + ((SMOOTHED(8, 13) < SMOOTHED(1, -16)) << 1) + ((SMOOTHED(-13, -5) < SMOOTHED(1, -17)) << 0));
+    desc[19] = (uchar)(((SMOOTHED(4, 6) < SMOOTHED(-8, -3)) << 7) + ((SMOOTHED(-5, -9) < SMOOTHED(-2, -10)) << 6) + ((SMOOTHED(-9, 0) < SMOOTHED(-7, -2)) << 5) + ((SMOOTHED(5, 0) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-4, -16) < SMOOTHED(6, 3)) << 3) + ((SMOOTHED(2, -15) < SMOOTHED(-2, 12)) << 2) + ((SMOOTHED(4, -1) < SMOOTHED(6, 2)) << 1) + ((SMOOTHED(1, 1) < SMOOTHED(-2, -8)) << 0));
+    desc[20] = (uchar)(((SMOOTHED(-2, 12) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, 8) < SMOOTHED(-9, 9)) << 6) + ((SMOOTHED(2, -10) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-4, 10) < SMOOTHED(-9, 4)) << 4) + ((SMOOTHED(6, 12) < SMOOTHED(2, 5)) << 3) + ((SMOOTHED(-3, -8) < SMOOTHED(0, 5)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-7, 2)) << 1) + ((SMOOTHED(-1, -10) < SMOOTHED(7, -18)) << 0));
+    desc[21] = (uchar)(((SMOOTHED(-1, 8) < SMOOTHED(-9, -10)) << 7) + ((SMOOTHED(-23, -1) < SMOOTHED(6, 2)) << 6) + ((SMOOTHED(-5, -3) < SMOOTHED(3, 2)) << 5) + ((SMOOTHED(0, 11) < SMOOTHED(-4, -7)) << 4) + ((SMOOTHED(15, 2) < SMOOTHED(-10, -3)) << 3) + ((SMOOTHED(-20, -8) < SMOOTHED(-13, 3)) << 2) + ((SMOOTHED(-19, -12) < SMOOTHED(5, -11)) << 1) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 0));
+    desc[22] = (uchar)(((SMOOTHED(7, 4) < SMOOTHED(-12, 0)) << 7) + ((SMOOTHED(5, -1) < SMOOTHED(-14, -6)) << 6) + ((SMOOTHED(-4, 11) < SMOOTHED(0, -4)) << 5) + ((SMOOTHED(3, 10) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(13, 21) < SMOOTHED(-11, 6)) << 3) + ((SMOOTHED(-12, 24) < SMOOTHED(-7, -4)) << 2) + ((SMOOTHED(4, 16) < SMOOTHED(3, -14)) << 1) + ((SMOOTHED(-3, 5) < SMOOTHED(-7, -12)) << 0));
+    desc[23] = (uchar)(((SMOOTHED(0, -4) < SMOOTHED(7, -5)) << 7) + ((SMOOTHED(-17, -9) < SMOOTHED(13, -7)) << 6) + ((SMOOTHED(22, -6) < SMOOTHED(-11, 5)) << 5) + ((SMOOTHED(2, -8) < SMOOTHED(23, -11)) << 4) + ((SMOOTHED(7, -10) < SMOOTHED(-1, 14)) << 3) + ((SMOOTHED(-3, -10) < SMOOTHED(8, 3)) << 2) + ((SMOOTHED(-13, 1) < SMOOTHED(-6, 0)) << 1) + ((SMOOTHED(-7, -21) < SMOOTHED(6, -14)) << 0));
+    desc[24] = (uchar)(((SMOOTHED(18, 19) < SMOOTHED(-4, -6)) << 7) + ((SMOOTHED(10, 7) < SMOOTHED(-1, -4)) << 6) + ((SMOOTHED(-1, 21) < SMOOTHED(1, -5)) << 5) + ((SMOOTHED(-10, 6) < SMOOTHED(-11, -2)) << 4) + ((SMOOTHED(18, -3) < SMOOTHED(-1, 7)) << 3) + ((SMOOTHED(-3, -9) < SMOOTHED(-5, 10)) << 2) + ((SMOOTHED(-13, 14) < SMOOTHED(17, -3)) << 1) + ((SMOOTHED(11, -19) < SMOOTHED(-1, -18)) << 0));
+    desc[25] = (uchar)(((SMOOTHED(8, -2) < SMOOTHED(-18, -23)) << 7) + ((SMOOTHED(0, -5) < SMOOTHED(-2, -9)) << 6) + ((SMOOTHED(-4, -11) < SMOOTHED(2, -8)) << 5) + ((SMOOTHED(14, 6) < SMOOTHED(-3, -6)) << 4) + ((SMOOTHED(-3, 0) < SMOOTHED(-15, 0)) << 3) + ((SMOOTHED(-9, 4) < SMOOTHED(-15, -9)) << 2) + ((SMOOTHED(-1, 11) < SMOOTHED(3, 11)) << 1) + ((SMOOTHED(-10, -16) < SMOOTHED(-7, 7)) << 0));
+    desc[26] = (uchar)(((SMOOTHED(-2, -10) < SMOOTHED(-10, -2)) << 7) + ((SMOOTHED(-5, -3) < SMOOTHED(5, -23)) << 6) + ((SMOOTHED(13, -8) < SMOOTHED(-15, -11)) << 5) + ((SMOOTHED(-15, 11) < SMOOTHED(6, -6)) << 4) + ((SMOOTHED(-16, -3) < SMOOTHED(-2, 2)) << 3) + ((SMOOTHED(6, 12) < SMOOTHED(-16, 24)) << 2) + ((SMOOTHED(-10, 0) < SMOOTHED(8, 11)) << 1) + ((SMOOTHED(-7, 7) < SMOOTHED(-19, -7)) << 0));
+    desc[27] = (uchar)(((SMOOTHED(5, 16) < SMOOTHED(9, -3)) << 7) + ((SMOOTHED(9, 7) < SMOOTHED(-7, -16)) << 6) + ((SMOOTHED(3, 2) < SMOOTHED(-10, 9)) << 5) + ((SMOOTHED(21, 1) < SMOOTHED(8, 7)) << 4) + ((SMOOTHED(7, 0) < SMOOTHED(1, 17)) << 3) + ((SMOOTHED(-8, 12) < SMOOTHED(9, 6)) << 2) + ((SMOOTHED(11, -7) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(19, 0) < SMOOTHED(9, 3)) << 0));
+    desc[28] = (uchar)(((SMOOTHED(1, -7) < SMOOTHED(-5, -11)) << 7) + ((SMOOTHED(0, 8) < SMOOTHED(-2, 14)) << 6) + ((SMOOTHED(12, -2) < SMOOTHED(-15, -6)) << 5) + ((SMOOTHED(4, 12) < SMOOTHED(0, -21)) << 4) + ((SMOOTHED(17, -4) < SMOOTHED(-6, -7)) << 3) + ((SMOOTHED(-10, -9) < SMOOTHED(-14, -7)) << 2) + ((SMOOTHED(-15, -10) < SMOOTHED(-15, -14)) << 1) + ((SMOOTHED(-7, -5) < SMOOTHED(5, -12)) << 0));
+    desc[29] = (uchar)(((SMOOTHED(-4, 0) < SMOOTHED(15, -4)) << 7) + ((SMOOTHED(5, 2) < SMOOTHED(-6, -23)) << 6) + ((SMOOTHED(-4, -21) < SMOOTHED(-6, 4)) << 5) + ((SMOOTHED(-10, 5) < SMOOTHED(-15, 6)) << 4) + ((SMOOTHED(4, -3) < SMOOTHED(-1, 5)) << 3) + ((SMOOTHED(-4, 19) < SMOOTHED(-23, -4)) << 2) + ((SMOOTHED(-4, 17) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(1, 12) < SMOOTHED(4, -14)) << 0));
+    desc[30] = (uchar)(((SMOOTHED(-11, -6) < SMOOTHED(-20, 10)) << 7) + ((SMOOTHED(4, 5) < SMOOTHED(3, 20)) << 6) + ((SMOOTHED(-8, -20) < SMOOTHED(3, 1)) << 5) + ((SMOOTHED(-19, 9) < SMOOTHED(9, -3)) << 4) + ((SMOOTHED(18, 15) < SMOOTHED(11, -4)) << 3) + ((SMOOTHED(12, 16) < SMOOTHED(8, 7)) << 2) + ((SMOOTHED(-14, -8) < SMOOTHED(-3, 9)) << 1) + ((SMOOTHED(-6, 0) < SMOOTHED(2, -4)) << 0));
+    desc[31] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-1, 2)) << 7) + ((SMOOTHED(8, -7) < SMOOTHED(-6, 18)) << 6) + ((SMOOTHED(9, 12) < SMOOTHED(-7, -23)) << 5) + ((SMOOTHED(8, -6) < SMOOTHED(5, 2)) << 4) + ((SMOOTHED(-9, 6) < SMOOTHED(-12, -7)) << 3) + ((SMOOTHED(-1, -2) < SMOOTHED(-7, 2)) << 2) + ((SMOOTHED(9, 9) < SMOOTHED(7, 15)) << 1) + ((SMOOTHED(6, 2) < SMOOTHED(-6, 6)) << 0));
+    desc[32] = (uchar)(((SMOOTHED(16, 12) < SMOOTHED(0, 19)) << 7) + ((SMOOTHED(4, 3) < SMOOTHED(6, 0)) << 6) + ((SMOOTHED(-2, -1) < SMOOTHED(2, 17)) << 5) + ((SMOOTHED(8, 1) < SMOOTHED(3, 1)) << 4) + ((SMOOTHED(-12, -1) < SMOOTHED(-11, 0)) << 3) + ((SMOOTHED(-11, 2) < SMOOTHED(7, 9)) << 2) + ((SMOOTHED(-1, 3) < SMOOTHED(-19, 4)) << 1) + ((SMOOTHED(-1, -11) < SMOOTHED(-1, 3)) << 0));
+    desc[33] = (uchar)(((SMOOTHED(1, -10) < SMOOTHED(-10, -4)) << 7) + ((SMOOTHED(-2, 3) < SMOOTHED(6, 11)) << 6) + ((SMOOTHED(3, 7) < SMOOTHED(-9, -8)) << 5) + ((SMOOTHED(24, -14) < SMOOTHED(-2, -10)) << 4) + ((SMOOTHED(-3, -3) < SMOOTHED(-18, -6)) << 3) + ((SMOOTHED(-13, -10) < SMOOTHED(-7, -1)) << 2) + ((SMOOTHED(2, -7) < SMOOTHED(9, -6)) << 1) + ((SMOOTHED(2, -4) < SMOOTHED(6, -13)) << 0));
+    desc[34] = (uchar)(((SMOOTHED(4, -4) < SMOOTHED(-2, 3)) << 7) + ((SMOOTHED(-4, 2) < SMOOTHED(9, 13)) << 6) + ((SMOOTHED(-11, 5) < SMOOTHED(-6, -11)) << 5) + ((SMOOTHED(4, -2) < SMOOTHED(11, -9)) << 4) + ((SMOOTHED(-19, 0) < SMOOTHED(-23, -5)) << 3) + ((SMOOTHED(-5, -7) < SMOOTHED(-3, -6)) << 2) + ((SMOOTHED(-6, -4) < SMOOTHED(12, 14)) << 1) + ((SMOOTHED(12, -11) < SMOOTHED(-8, -16)) << 0));
+    desc[35] = (uchar)(((SMOOTHED(-21, 15) < SMOOTHED(-12, 6)) << 7) + ((SMOOTHED(-2, -1) < SMOOTHED(-8, 16)) << 6) + ((SMOOTHED(6, -1) < SMOOTHED(-8, -2)) << 5) + ((SMOOTHED(1, -1) < SMOOTHED(-9, 8)) << 4) + ((SMOOTHED(3, -4) < SMOOTHED(-2, -2)) << 3) + ((SMOOTHED(-7, 0) < SMOOTHED(4, -8)) << 2) + ((SMOOTHED(11, -11) < SMOOTHED(-12, 2)) << 1) + ((SMOOTHED(2, 3) < SMOOTHED(11, 7)) << 0));
+    desc[36] = (uchar)(((SMOOTHED(-7, -4) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(3, -7) < SMOOTHED(-5, 0)) << 6) + ((SMOOTHED(3, -7) < SMOOTHED(-10, -5)) << 5) + ((SMOOTHED(-3, -1) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(0, 8) < SMOOTHED(5, 1)) << 3) + ((SMOOTHED(9, 0) < SMOOTHED(1, 16)) << 2) + ((SMOOTHED(8, 4) < SMOOTHED(-11, -3)) << 1) + ((SMOOTHED(-15, 9) < SMOOTHED(8, 17)) << 0));
+    desc[37] = (uchar)(((SMOOTHED(0, 2) < SMOOTHED(-9, 17)) << 7) + ((SMOOTHED(-6, -11) < SMOOTHED(-10, -3)) << 6) + ((SMOOTHED(1, 1) < SMOOTHED(15, -8)) << 5) + ((SMOOTHED(-12, -13) < SMOOTHED(-2, 4)) << 4) + ((SMOOTHED(-6, 4) < SMOOTHED(-6, -10)) << 3) + ((SMOOTHED(5, -7) < SMOOTHED(7, -5)) << 2) + ((SMOOTHED(10, 6) < SMOOTHED(8, 9)) << 1) + ((SMOOTHED(-5, 7) < SMOOTHED(-18, -3)) << 0));
+    desc[38] = (uchar)(((SMOOTHED(-6, 3) < SMOOTHED(5, 4)) << 7) + ((SMOOTHED(-10, -13) < SMOOTHED(-5, -3)) << 6) + ((SMOOTHED(-11, 2) < SMOOTHED(-16, 0)) << 5) + ((SMOOTHED(7, -21) < SMOOTHED(-5, -13)) << 4) + ((SMOOTHED(-14, -14) < SMOOTHED(-4, -4)) << 3) + ((SMOOTHED(4, 9) < SMOOTHED(7, -3)) << 2) + ((SMOOTHED(4, 11) < SMOOTHED(10, -4)) << 1) + ((SMOOTHED(6, 17) < SMOOTHED(9, 17)) << 0));
+    desc[39] = (uchar)(((SMOOTHED(-10, 8) < SMOOTHED(0, -11)) << 7) + ((SMOOTHED(-6, -16) < SMOOTHED(-6, 8)) << 6) + ((SMOOTHED(-13, 5) < SMOOTHED(10, -5)) << 5) + ((SMOOTHED(3, 2) < SMOOTHED(12, 16)) << 4) + ((SMOOTHED(13, -8) < SMOOTHED(0, -6)) << 3) + ((SMOOTHED(10, 0) < SMOOTHED(4, -11)) << 2) + ((SMOOTHED(8, 5) < SMOOTHED(10, -2)) << 1) + ((SMOOTHED(11, -7) < SMOOTHED(-13, 3)) << 0));
+    desc[40] = (uchar)(((SMOOTHED(2, 4) < SMOOTHED(-7, -3)) << 7) + ((SMOOTHED(-14, -2) < SMOOTHED(-11, 16)) << 6) + ((SMOOTHED(11, -6) < SMOOTHED(7, 6)) << 5) + ((SMOOTHED(-3, 15) < SMOOTHED(8, -10)) << 4) + ((SMOOTHED(-3, 8) < SMOOTHED(12, -12)) << 3) + ((SMOOTHED(-13, 6) < SMOOTHED(-14, 7)) << 2) + ((SMOOTHED(-11, -5) < SMOOTHED(-8, -6)) << 1) + ((SMOOTHED(7, -6) < SMOOTHED(6, 3)) << 0));
+    desc[41] = (uchar)(((SMOOTHED(-4, 10) < SMOOTHED(5, 1)) << 7) + ((SMOOTHED(9, 16) < SMOOTHED(10, 13)) << 6) + ((SMOOTHED(-17, 10) < SMOOTHED(2, 8)) << 5) + ((SMOOTHED(-5, 1) < SMOOTHED(4, -4)) << 4) + ((SMOOTHED(-14, 8) < SMOOTHED(-5, 2)) << 3) + ((SMOOTHED(4, -9) < SMOOTHED(-6, -3)) << 2) + ((SMOOTHED(3, -7) < SMOOTHED(-10, 0)) << 1) + ((SMOOTHED(-2, -8) < SMOOTHED(-10, 4)) << 0));
+    desc[42] = (uchar)(((SMOOTHED(-8, 5) < SMOOTHED(-9, 24)) << 7) + ((SMOOTHED(2, -8) < SMOOTHED(8, -9)) << 6) + ((SMOOTHED(-4, 17) < SMOOTHED(-5, 2)) << 5) + ((SMOOTHED(14, 0) < SMOOTHED(-9, 9)) << 4) + ((SMOOTHED(11, 15) < SMOOTHED(-6, 5)) << 3) + ((SMOOTHED(-8, 1) < SMOOTHED(-3, 4)) << 2) + ((SMOOTHED(9, -21) < SMOOTHED(10, 2)) << 1) + ((SMOOTHED(2, -1) < SMOOTHED(4, 11)) << 0));
+    desc[43] = (uchar)(((SMOOTHED(24, 3) < SMOOTHED(2, -2)) << 7) + ((SMOOTHED(-8, 17) < SMOOTHED(-14, -10)) << 6) + ((SMOOTHED(6, 5) < SMOOTHED(-13, 7)) << 5) + ((SMOOTHED(11, 10) < SMOOTHED(0, -1)) << 4) + ((SMOOTHED(4, 6) < SMOOTHED(-10, 6)) << 3) + ((SMOOTHED(-12, -2) < SMOOTHED(5, 6)) << 2) + ((SMOOTHED(3, -1) < SMOOTHED(8, -15)) << 1) + ((SMOOTHED(1, -4) < SMOOTHED(-7, 11)) << 0));
+    desc[44] = (uchar)(((SMOOTHED(1, 11) < SMOOTHED(5, 0)) << 7) + ((SMOOTHED(6, -12) < SMOOTHED(10, 1)) << 6) + ((SMOOTHED(-3, -2) < SMOOTHED(-1, 4)) << 5) + ((SMOOTHED(-2, -11) < SMOOTHED(-1, 12)) << 4) + ((SMOOTHED(7, -8) < SMOOTHED(-20, -18)) << 3) + ((SMOOTHED(2, 0) < SMOOTHED(-9, 2)) << 2) + ((SMOOTHED(-13, -1) < SMOOTHED(-16, 2)) << 1) + ((SMOOTHED(3, -1) < SMOOTHED(-5, -17)) << 0));
+    desc[45] = (uchar)(((SMOOTHED(15, 8) < SMOOTHED(3, -14)) << 7) + ((SMOOTHED(-13, -12) < SMOOTHED(6, 15)) << 6) + ((SMOOTHED(2, -8) < SMOOTHED(2, 6)) << 5) + ((SMOOTHED(6, 22) < SMOOTHED(-3, -23)) << 4) + ((SMOOTHED(-2, -7) < SMOOTHED(-6, 0)) << 3) + ((SMOOTHED(13, -10) < SMOOTHED(-6, 6)) << 2) + ((SMOOTHED(6, 7) < SMOOTHED(-10, 12)) << 1) + ((SMOOTHED(-6, 7) < SMOOTHED(-2, 11)) << 0));
+    desc[46] = (uchar)(((SMOOTHED(0, -22) < SMOOTHED(-2, -17)) << 7) + ((SMOOTHED(-4, -1) < SMOOTHED(-11, -14)) << 6) + ((SMOOTHED(-2, -8) < SMOOTHED(7, 12)) << 5) + ((SMOOTHED(12, -5) < SMOOTHED(7, -13)) << 4) + ((SMOOTHED(2, -2) < SMOOTHED(-7, 6)) << 3) + ((SMOOTHED(0, 8) < SMOOTHED(-3, 23)) << 2) + ((SMOOTHED(6, 12) < SMOOTHED(13, -11)) << 1) + ((SMOOTHED(-21, -10) < SMOOTHED(10, 8)) << 0));
+    desc[47] = (uchar)(((SMOOTHED(-3, 0) < SMOOTHED(7, 15)) << 7) + ((SMOOTHED(7, -6) < SMOOTHED(-5, -12)) << 6) + ((SMOOTHED(-21, -10) < SMOOTHED(12, -11)) << 5) + ((SMOOTHED(-5, -11) < SMOOTHED(8, -11)) << 4) + ((SMOOTHED(5, 0) < SMOOTHED(-11, -1)) << 3) + ((SMOOTHED(8, -9) < SMOOTHED(7, -1)) << 2) + ((SMOOTHED(11, -23) < SMOOTHED(21, -5)) << 1) + ((SMOOTHED(0, -5) < SMOOTHED(-8, 6)) << 0));
+    desc[48] = (uchar)(((SMOOTHED(-6, 8) < SMOOTHED(8, 12)) << 7) + ((SMOOTHED(-7, 5) < SMOOTHED(3, -2)) << 6) + ((SMOOTHED(-5, -20) < SMOOTHED(-12, 9)) << 5) + ((SMOOTHED(-6, 12) < SMOOTHED(-11, 3)) << 4) + ((SMOOTHED(4, 5) < SMOOTHED(13, 11)) << 3) + ((SMOOTHED(2, 12) < SMOOTHED(13, -12)) << 2) + ((SMOOTHED(-4, -13) < SMOOTHED(4, 7)) << 1) + ((SMOOTHED(0, 15) < SMOOTHED(-3, -16)) << 0));
+    desc[49] = (uchar)(((SMOOTHED(-3, 2) < SMOOTHED(-2, 14)) << 7) + ((SMOOTHED(4, -14) < SMOOTHED(16, -11)) << 6) + ((SMOOTHED(-13, 3) < SMOOTHED(23, 10)) << 5) + ((SMOOTHED(9, -19) < SMOOTHED(2, 5)) << 4) + ((SMOOTHED(5, 3) < SMOOTHED(14, -7)) << 3) + ((SMOOTHED(19, -13) < SMOOTHED(-11, 15)) << 2) + ((SMOOTHED(14, 0) < SMOOTHED(-2, -5)) << 1) + ((SMOOTHED(11, -4) < SMOOTHED(0, -6)) << 0));
+    desc[50] = (uchar)(((SMOOTHED(-2, 5) < SMOOTHED(-13, -8)) << 7) + ((SMOOTHED(-11, -15) < SMOOTHED(-7, -17)) << 6) + ((SMOOTHED(1, 3) < SMOOTHED(-10, -8)) << 5) + ((SMOOTHED(-13, -10) < SMOOTHED(7, -12)) << 4) + ((SMOOTHED(0, -13) < SMOOTHED(23, -6)) << 3) + ((SMOOTHED(2, -17) < SMOOTHED(-7, -3)) << 2) + ((SMOOTHED(1, 3) < SMOOTHED(4, -10)) << 1) + ((SMOOTHED(13, 4) < SMOOTHED(14, -6)) << 0));
+    desc[51] = (uchar)(((SMOOTHED(-19, -2) < SMOOTHED(-1, 5)) << 7) + ((SMOOTHED(9, -8) < SMOOTHED(10, -5)) << 6) + ((SMOOTHED(7, -1) < SMOOTHED(5, 7)) << 5) + ((SMOOTHED(9, -10) < SMOOTHED(19, 0)) << 4) + ((SMOOTHED(7, 5) < SMOOTHED(-4, -7)) << 3) + ((SMOOTHED(-11, 1) < SMOOTHED(-1, -11)) << 2) + ((SMOOTHED(2, -1) < SMOOTHED(-4, 11)) << 1) + ((SMOOTHED(-1, 7) < SMOOTHED(2, -2)) << 0));
+    desc[52] = (uchar)(((SMOOTHED(1, -20) < SMOOTHED(-9, -6)) << 7) + ((SMOOTHED(-4, -18) < SMOOTHED(8, -18)) << 6) + ((SMOOTHED(-16, -2) < SMOOTHED(7, -6)) << 5) + ((SMOOTHED(-3, -6) < SMOOTHED(-1, -4)) << 4) + ((SMOOTHED(0, -16) < SMOOTHED(24, -5)) << 3) + ((SMOOTHED(-4, -2) < SMOOTHED(-1, 9)) << 2) + ((SMOOTHED(-8, 2) < SMOOTHED(-6, 15)) << 1) + ((SMOOTHED(11, 4) < SMOOTHED(0, -3)) << 0));
+    desc[53] = (uchar)(((SMOOTHED(7, 6) < SMOOTHED(2, -10)) << 7) + ((SMOOTHED(-7, -9) < SMOOTHED(12, -6)) << 6) + ((SMOOTHED(24, 15) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(15, -9) < SMOOTHED(-3, -15)) << 4) + ((SMOOTHED(17, -5) < SMOOTHED(11, -10)) << 3) + ((SMOOTHED(-2, 13) < SMOOTHED(-15, 4)) << 2) + ((SMOOTHED(-2, -1) < SMOOTHED(4, -23)) << 1) + ((SMOOTHED(-16, 3) < SMOOTHED(-7, -14)) << 0));
+    desc[54] = (uchar)(((SMOOTHED(-3, -5) < SMOOTHED(-10, -9)) << 7) + ((SMOOTHED(-5, 3) < SMOOTHED(-2, -1)) << 6) + ((SMOOTHED(-1, 4) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(12, 9) < SMOOTHED(9, -14)) << 4) + ((SMOOTHED(-9, 17) < SMOOTHED(-3, 0)) << 3) + ((SMOOTHED(5, 4) < SMOOTHED(13, -6)) << 2) + ((SMOOTHED(-1, -8) < SMOOTHED(19, 10)) << 1) + ((SMOOTHED(8, -5) < SMOOTHED(-15, 2)) << 0));
+    desc[55] = (uchar)(((SMOOTHED(-12, -9) < SMOOTHED(-4, -5)) << 7) + ((SMOOTHED(12, 0) < SMOOTHED(24, 4)) << 6) + ((SMOOTHED(8, -2) < SMOOTHED(14, 4)) << 5) + ((SMOOTHED(8, -4) < SMOOTHED(-7, 16)) << 4) + ((SMOOTHED(5, -1) < SMOOTHED(-8, -4)) << 3) + ((SMOOTHED(-2, 18) < SMOOTHED(-5, 17)) << 2) + ((SMOOTHED(8, -2) < SMOOTHED(-9, -2)) << 1) + ((SMOOTHED(3, -7) < SMOOTHED(1, -6)) << 0));
+    desc[56] = (uchar)(((SMOOTHED(-5, -22) < SMOOTHED(-5, -2)) << 7) + ((SMOOTHED(-8, -10) < SMOOTHED(14, 1)) << 6) + ((SMOOTHED(-3, -13) < SMOOTHED(3, 9)) << 5) + ((SMOOTHED(-4, -1) < SMOOTHED(-1, 0)) << 4) + ((SMOOTHED(-7, -21) < SMOOTHED(12, -19)) << 3) + ((SMOOTHED(-8, 8) < SMOOTHED(24, 8)) << 2) + ((SMOOTHED(12, -6) < SMOOTHED(-2, 3)) << 1) + ((SMOOTHED(-5, -11) < SMOOTHED(-22, -4)) << 0));
+    desc[57] = (uchar)(((SMOOTHED(-3, 5) < SMOOTHED(-4, 4)) << 7) + ((SMOOTHED(-16, 24) < SMOOTHED(7, -9)) << 6) + ((SMOOTHED(-10, 23) < SMOOTHED(-9, 18)) << 5) + ((SMOOTHED(1, 12) < SMOOTHED(17, 21)) << 4) + ((SMOOTHED(24, -6) < SMOOTHED(-3, -11)) << 3) + ((SMOOTHED(-7, 17) < SMOOTHED(1, -6)) << 2) + ((SMOOTHED(4, 4) < SMOOTHED(2, -7)) << 1) + ((SMOOTHED(14, 6) < SMOOTHED(-12, 3)) << 0));
+    desc[58] = (uchar)(((SMOOTHED(-6, 0) < SMOOTHED(-16, 13)) << 7) + ((SMOOTHED(-10, 5) < SMOOTHED(7, 12)) << 6) + ((SMOOTHED(5, 2) < SMOOTHED(6, -3)) << 5) + ((SMOOTHED(7, 0) < SMOOTHED(-23, 1)) << 4) + ((SMOOTHED(15, -5) < SMOOTHED(1, 14)) << 3) + ((SMOOTHED(-3, -1) < SMOOTHED(6, 6)) << 2) + ((SMOOTHED(6, -9) < SMOOTHED(-9, 12)) << 1) + ((SMOOTHED(4, -2) < SMOOTHED(-4, 7)) << 0));
+    desc[59] = (uchar)(((SMOOTHED(-4, -5) < SMOOTHED(4, 4)) << 7) + ((SMOOTHED(-13, 0) < SMOOTHED(6, -10)) << 6) + ((SMOOTHED(2, -12) < SMOOTHED(-6, -3)) << 5) + ((SMOOTHED(16, 0) < SMOOTHED(-3, 3)) << 4) + ((SMOOTHED(5, -14) < SMOOTHED(6, 11)) << 3) + ((SMOOTHED(5, 11) < SMOOTHED(0, -13)) << 2) + ((SMOOTHED(7, 5) < SMOOTHED(-1, -5)) << 1) + ((SMOOTHED(12, 4) < SMOOTHED(6, 10)) << 0));
+    desc[60] = (uchar)(((SMOOTHED(-10, 4) < SMOOTHED(-1, -11)) << 7) + ((SMOOTHED(4, 10) < SMOOTHED(-14, 5)) << 6) + ((SMOOTHED(11, -14) < SMOOTHED(-13, 0)) << 5) + ((SMOOTHED(2, 8) < SMOOTHED(12, 24)) << 4) + ((SMOOTHED(-1, 3) < SMOOTHED(-1, 2)) << 3) + ((SMOOTHED(9, -14) < SMOOTHED(-23, 3)) << 2) + ((SMOOTHED(-8, -6) < SMOOTHED(0, 9)) << 1) + ((SMOOTHED(-15, 14) < SMOOTHED(10, -10)) << 0));
+    desc[61] = (uchar)(((SMOOTHED(-10, -6) < SMOOTHED(-7, -5)) << 7) + ((SMOOTHED(11, 5) < SMOOTHED(-3, -15)) << 6) + ((SMOOTHED(1, 0) < SMOOTHED(1, 8)) << 5) + ((SMOOTHED(-11, -6) < SMOOTHED(-4, -18)) << 4) + ((SMOOTHED(9, 0) < SMOOTHED(22, -4)) << 3) + ((SMOOTHED(-5, -1) < SMOOTHED(-9, 4)) << 2) + ((SMOOTHED(-20, 2) < SMOOTHED(1, 6)) << 1) + ((SMOOTHED(1, 2) < SMOOTHED(-9, -12)) << 0));
+    desc[62] = (uchar)(((SMOOTHED(5, 15) < SMOOTHED(4, -6)) << 7) + ((SMOOTHED(19, 4) < SMOOTHED(4, 11)) << 6) + ((SMOOTHED(17, -4) < SMOOTHED(-8, -1)) << 5) + ((SMOOTHED(-8, -12) < SMOOTHED(7, -3)) << 4) + ((SMOOTHED(11, 9) < SMOOTHED(8, 1)) << 3) + ((SMOOTHED(9, 22) < SMOOTHED(-15, 15)) << 2) + ((SMOOTHED(-7, -7) < SMOOTHED(1, -23)) << 1) + ((SMOOTHED(-5, 13) < SMOOTHED(-8, 2)) << 0));
+    desc[63] = (uchar)(((SMOOTHED(3, -5) < SMOOTHED(11, -11)) << 7) + ((SMOOTHED(3, -18) < SMOOTHED(14, -5)) << 6) + ((SMOOTHED(-20, 7) < SMOOTHED(-10, -23)) << 5) + ((SMOOTHED(-2, -5) < SMOOTHED(6, 0)) << 4) + ((SMOOTHED(-17, -13) < SMOOTHED(-3, 2)) << 3) + ((SMOOTHED(-6, -1) < SMOOTHED(14, -2)) << 2) + ((SMOOTHED(-12, -16) < SMOOTHED(15, 6)) << 1) + ((SMOOTHED(-12, -2) < SMOOTHED(3, -19)) << 0));
 #undef SMOOTHED
diff --git a/modules/features2d/src/keypoint.cpp b/modules/features2d/src/keypoint.cpp
index 01717f76da..f71186d16f 100644
--- a/modules/features2d/src/keypoint.cpp
+++ b/modules/features2d/src/keypoint.cpp
@@ -119,6 +119,7 @@ void KeyPoint::convert(const std::vector<KeyPoint>& keypoints, std::vector<Point
 void KeyPoint::convert( const std::vector<Point2f>& points2f, std::vector<KeyPoint>& keypoints,
                         float size, float response, int octave, int class_id )
 {
+    keypoints.resize(points2f.size());
     for( size_t i = 0; i < points2f.size(); i++ )
         keypoints[i] = KeyPoint(points2f[i], size, -1, response, octave, class_id);
 }
diff --git a/modules/features2d/src/matchers.cpp b/modules/features2d/src/matchers.cpp
index 1093901157..795cc1afeb 100755
--- a/modules/features2d/src/matchers.cpp
+++ b/modules/features2d/src/matchers.cpp
@@ -328,6 +328,10 @@ Ptr<DescriptorMatcher> DescriptorMatcher::create( const string& descriptorMatche
     {
         dm = new BruteForceMatcher<L2<float> >();
     }
+    else if( !descriptorMatcherType.compare( "BruteForce-SL2" ) ) // Squared L2
+    {
+        dm = new BruteForceMatcher<SL2<float> >();
+    }
     else if( !descriptorMatcherType.compare( "BruteForce-L1" ) )
     {
         dm = new BruteForceMatcher<L1<float> >();
@@ -345,10 +349,10 @@ Ptr<DescriptorMatcher> DescriptorMatcher::create( const string& descriptorMatche
 }
 
 /*
- * BruteForce L2 specialization
+ * BruteForce SL2 and L2 specialization
  */
 template<>
-void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
+void BruteForceMatcher<SL2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
                                               const vector<Mat>& masks, bool compactResult )
 {
 #ifndef HAVE_EIGEN
@@ -427,7 +431,7 @@ void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, v
                     break;
 
                 e_allDists[bestImgIdx](bestTrainIdx) = -std::numeric_limits<float>::max();
-                curMatches->push_back( DMatch(qIdx, bestTrainIdx, bestImgIdx, sqrt((-2)*totalMaxCoeff + queryNorm2)) );
+                curMatches->push_back( DMatch(qIdx, bestTrainIdx, bestImgIdx, (-2)*totalMaxCoeff + queryNorm2) );
             }
             std::sort( curMatches->begin(), curMatches->end() );
         }
@@ -436,7 +440,7 @@ void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, v
 }
 
 template<>
-void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
+void BruteForceMatcher<SL2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
                                                      const vector<Mat>& masks, bool compactResult )
 {
 #ifndef HAVE_EIGEN
@@ -492,7 +496,7 @@ void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors
                 {
                     if( masks.empty() || isPossibleMatch(masks[iIdx], qIdx, tIdx) )
                     {
-                        float d =  sqrt((-2)*e_allDists[iIdx](tIdx) + queryNorm2);
+                        float d =  (-2)*e_allDists[iIdx](tIdx) + queryNorm2;
                         if( d < maxDistance )
                             curMatches->push_back( DMatch( qIdx, tIdx, iIdx, d ) );
                     }
@@ -504,6 +508,40 @@ void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors
 #endif
 }
 
+inline void sqrtDistance( vector<vector<DMatch> >& matches )
+{
+    for( size_t imgIdx = 0; imgIdx < matches.size(); imgIdx++ )
+    {
+        for( size_t matchIdx = 0; matchIdx < matches[imgIdx].size(); matchIdx++ )
+        {
+            matches[imgIdx][matchIdx].distance = std::sqrt( matches[imgIdx][matchIdx].distance );
+        }
+    }
+}
+
+template<>
+void BruteForceMatcher<L2<float> >::knnMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, int knn,
+                                              const vector<Mat>& masks, bool compactResult )
+{
+    BruteForceMatcher<SL2<float> > matcherSL2;
+    matcherSL2.add( getTrainDescriptors() );
+    matcherSL2.knnMatch( queryDescriptors, matches, knn, masks, compactResult );
+
+    sqrtDistance( matches );
+}
+
+template<>
+void BruteForceMatcher<L2<float> >::radiusMatchImpl( const Mat& queryDescriptors, vector<vector<DMatch> >& matches, float maxDistance,
+                                                     const vector<Mat>& masks, bool compactResult )
+{
+    const float maxDistance2 = maxDistance * maxDistance;
+    BruteForceMatcher<SL2<float> > matcherSL2;
+    matcherSL2.add( getTrainDescriptors() );
+    matcherSL2.radiusMatch( queryDescriptors, matches, maxDistance2, masks, compactResult );
+
+    sqrtDistance( matches );
+}
+
 /*
  * Flann based matcher
  */
@@ -542,6 +580,195 @@ void FlannBasedMatcher::train()
     }
 }
 
+void FlannBasedMatcher::read( const FileNode& fn)
+{
+     if (indexParams == 0)
+         indexParams = new flann::IndexParams();
+
+     FileNode ip = fn["indexParams"];
+     CV_Assert(ip.type() == FileNode::SEQ);
+
+     for(size_t i = 0; i < ip.size(); ++i)
+     {
+        CV_Assert(ip[i].type() == FileNode::MAP);
+        std::string name =  (std::string)ip[i]["name"];
+        int type =  (int)ip[i]["type"];
+
+        switch(type)
+        {
+        case CV_8U:
+        case CV_8S:
+        case CV_16U:
+        case CV_16S:
+        case CV_32S:
+            indexParams->setInt(name, (int) ip[i]["value"]);
+            break;
+        case CV_32F:
+            indexParams->setFloat(name, (float) ip[i]["value"]);
+            break;
+        case CV_64F:
+            indexParams->setDouble(name, (double) ip[i]["value"]);
+            break;
+        case CV_USRTYPE1:
+            indexParams->setString(name, (std::string) ip[i]["value"]);
+            break;
+        case CV_MAKETYPE(CV_USRTYPE1,2):
+            indexParams->setBool(name, (int) ip[i]["value"]);
+            break;
+        case CV_MAKETYPE(CV_USRTYPE1,3):
+            indexParams->setAlgorithm(name, (int) ip[i]["value"]);
+            break;
+        };
+     }
+
+     if (searchParams == 0)
+         searchParams = new flann::SearchParams();
+
+     FileNode sp = fn["searchParams"];
+     CV_Assert(sp.type() == FileNode::SEQ);
+
+     for(size_t i = 0; i < sp.size(); ++i)
+     {
+        CV_Assert(sp[i].type() == FileNode::MAP);
+        std::string name =  (std::string)sp[i]["name"];
+        int type =  (int)sp[i]["type"];
+
+        switch(type)
+        {
+        case CV_8U:
+        case CV_8S:
+        case CV_16U:
+        case CV_16S:
+        case CV_32S:
+            searchParams->setInt(name, (int) sp[i]["value"]);
+            break;
+        case CV_32F:
+            searchParams->setFloat(name, (float) ip[i]["value"]);
+            break;
+        case CV_64F:
+            searchParams->setDouble(name, (double) ip[i]["value"]);
+            break;
+        case CV_USRTYPE1:
+            searchParams->setString(name, (std::string) ip[i]["value"]);
+            break;
+        case CV_MAKETYPE(CV_USRTYPE1,2):
+            searchParams->setBool(name, (int) ip[i]["value"]);
+            break;
+        case CV_MAKETYPE(CV_USRTYPE1,3):
+            searchParams->setAlgorithm(name, (int) ip[i]["value"]);
+            break;
+        };
+     }
+
+    flannIndex.release();
+}
+
+void FlannBasedMatcher::write( FileStorage& fs) const
+{
+     fs << "indexParams" << "[";
+
+     if (indexParams != 0)
+     {
+         std::vector<std::string> names;
+         std::vector<int> types;
+         std::vector<std::string> strValues;
+         std::vector<double> numValues;
+
+         indexParams->getAll(names, types, strValues, numValues);
+
+         for(size_t i = 0; i < names.size(); ++i)
+         {
+             fs << "{" << "name" << names[i] << "type" << types[i] << "value";
+             switch(types[i])
+             {
+             case CV_8U:
+                 fs << (uchar)numValues[i];
+                 break;
+             case CV_8S:
+                 fs << (char)numValues[i];
+                 break;
+             case CV_16U:
+                 fs << (ushort)numValues[i];
+                 break;
+             case CV_16S:
+                 fs << (short)numValues[i];
+                 break;
+             case CV_32S:
+             case CV_MAKETYPE(CV_USRTYPE1,2):
+             case CV_MAKETYPE(CV_USRTYPE1,3):
+                 fs << (int)numValues[i];
+                 break;
+             case CV_32F:
+                 fs << (float)numValues[i];
+                 break;
+             case CV_64F:
+                 fs << (double)numValues[i];
+                 break;
+             case CV_USRTYPE1:
+                 fs << strValues[i];
+                 break;
+             default:
+                 fs << (double)numValues[i];
+                 fs << "typename" << strValues[i];
+                 break;
+             }
+             fs << "}";
+         }
+     }
+
+     fs << "]" << "searchParams" << "[";
+
+     if (searchParams != 0)
+     {
+         std::vector<std::string> names;
+         std::vector<int> types;
+         std::vector<std::string> strValues;
+         std::vector<double> numValues;
+
+         searchParams->getAll(names, types, strValues, numValues);
+
+         for(size_t i = 0; i < names.size(); ++i)
+         {
+             fs << "{" << "name" << names[i] << "type" << types[i] << "value";
+             switch(types[i])
+             {
+             case CV_8U:
+                 fs << (uchar)numValues[i];
+                 break;
+             case CV_8S:
+                 fs << (char)numValues[i];
+                 break;
+             case CV_16U:
+                 fs << (ushort)numValues[i];
+                 break;
+             case CV_16S:
+                 fs << (short)numValues[i];
+                 break;
+             case CV_32S:
+             case CV_MAKETYPE(CV_USRTYPE1,2):
+             case CV_MAKETYPE(CV_USRTYPE1,3):
+                 fs << (int)numValues[i];
+                 break;
+             case CV_32F:
+                 fs << (float)numValues[i];
+                 break;
+             case CV_64F:
+                 fs << (double)numValues[i];
+                 break;
+             case CV_USRTYPE1:
+                 fs << strValues[i];
+                 break;
+             default:
+                 fs << (double)numValues[i];
+                 fs << "typename" << strValues[i];
+                 break;
+             }
+             fs << "}";
+         }
+     }
+     fs << "]";
+}
+
 bool FlannBasedMatcher::isMaskSupported() const
 {
     return false;
@@ -603,7 +830,7 @@ void FlannBasedMatcher::radiusMatchImpl( const Mat& queryDescriptors, vector<vec
         Mat queryDescriptorsRow = queryDescriptors.row(qIdx);
         Mat indicesRow = indices.row(qIdx);
         Mat distsRow = dists.row(qIdx);
-        flannIndex->radiusSearch( queryDescriptorsRow, indicesRow, distsRow, maxDistance*maxDistance, *searchParams );
+        flannIndex->radiusSearch( queryDescriptorsRow, indicesRow, distsRow, maxDistance*maxDistance, count, *searchParams );
     }
 
     convertToDMatches( mergedDescriptors, indices, dists, matches );
diff --git a/modules/features2d/src/orb.cpp b/modules/features2d/src/orb.cpp
index 90b1655f6c..15c14f3e46 100644
--- a/modules/features2d/src/orb.cpp
+++ b/modules/features2d/src/orb.cpp
@@ -58,7 +58,7 @@ template<typename PatchType, typename SumType>
     SumType * dX_data = reinterpret_cast<SumType*> (dX.data), *dY_data = reinterpret_cast<SumType*> (dY.data);
     SumType * dX_data_end = dX_data + 9 * 7;
     PatchType * patch_data = reinterpret_cast<PatchType*> (patch.data);
-    int two_row_offset = 2 * patch.step1();
+    int two_row_offset = (int)(2 * patch.step1());
     std::vector<int>::const_iterator dX_offset = dX_offsets.begin(), dY_offset = dY_offsets.begin();
     // Compute the differences
     for (; dX_data != dX_data_end; ++dX_data, ++dY_data, ++dX_offset, ++dY_offset)
@@ -127,11 +127,11 @@ HarrisResponse::HarrisResponse(const cv::Mat& image, double k) :
   dX_offsets_.resize(7 * 9);
   dY_offsets_.resize(7 * 9);
   std::vector<int>::iterator dX_offsets = dX_offsets_.begin(), dY_offsets = dY_offsets_.begin();
-  unsigned int image_step = (unsigned int)image.step1();
-  for (size_t y = 0; y <= 6 * image_step; y += image_step)
+  int x, y, image_step = (int)image.step1();
+  for (y = 0; y <= 6 * image_step; y += image_step)
   {
     int dX_offset = y + 2, dY_offset = y + 2 * image_step;
-    for (size_t x = 0; x <= 6; ++x)
+    for (x = 0; x <= 6; ++x)
     {
       *(dX_offsets++) = dX_offset++;
       *(dY_offsets++) = dY_offset++;
@@ -140,10 +140,10 @@ HarrisResponse::HarrisResponse(const cv::Mat& image, double k) :
       *(dY_offsets++) = dY_offset++;
   }
 
-  for (size_t y = 7 * image_step; y <= 8 * image_step; y += image_step)
+  for (y = 7 * image_step; y <= 8 * image_step; y += image_step)
   {
     int dX_offset = y + 2;
-    for (size_t x = 0; x <= 6; ++x)
+    for (x = 0; x <= 6; ++x)
       *(dX_offsets++) = dX_offset++;
   }
 }
@@ -405,16 +405,17 @@ private:
     }
 
     int half_kernel = ORB::kKernelWidth / 2;
-    for (unsigned int i = 0; i < 512; ++i)
+    for (int i = 0; i < 512; ++i)
     {
-      int center = *(pattern_data + 2 * i) + normalized_step_ * (*(pattern_data + 2 * i + 1));
+      int center = (int)(*(pattern_data + 2 * i) + normalized_step_ * (*(pattern_data + 2 * i + 1)));
+      int nstep = (int)normalized_step_;
       // Points in order 01
       //                 32
       // +1 is added for certain coordinates for the integral image
-      *(relative_pattern_data++) = center - half_kernel - half_kernel * normalized_step_;
-      *(relative_pattern_data++) = center + (half_kernel + 1) - half_kernel * normalized_step_;
-      *(relative_pattern_data++) = center + (half_kernel + 1) + (half_kernel + 1) * normalized_step_;
-      *(relative_pattern_data++) = center - half_kernel + (half_kernel + 1) * normalized_step_;
+      *(relative_pattern_data++) = center - half_kernel - half_kernel * nstep;
+      *(relative_pattern_data++) = center + (half_kernel + 1) - half_kernel * nstep;
+      *(relative_pattern_data++) = center + (half_kernel + 1) + (half_kernel + 1) * nstep;
+      *(relative_pattern_data++) = center - half_kernel + (half_kernel + 1) * nstep;
     }
   }
 
@@ -765,8 +766,8 @@ void ORB::computeIntegralImage(const cv::Mat & image, unsigned int level, cv::Ma
   integral(image, integral_image, CV_32S);
   integral_image_steps_.resize(params_.n_levels_, 0);
 
-  unsigned int integral_image_step = integral_image.step1();
-  if (integral_image_steps_[level] == integral_image_step)
+  int integral_image_step = (int)integral_image.step1();
+  if ((int)integral_image_steps_[level] == integral_image_step)
     return;
 
   // If the integral image dimensions have changed, recompute everything
@@ -828,11 +829,11 @@ void ORB::computeDescriptors(const cv::Mat& image, const cv::Mat& integral_image
   OrbPatterns* patterns = patterns_[level];
 
   //create the descriptor mat, keypoints.size() rows, BYTES cols
-  descriptors = cv::Mat::zeros(keypoints.size(), kBytes, CV_8UC1);
+  descriptors = cv::Mat::zeros((int)keypoints.size(), kBytes, CV_8UC1);
 
   for (size_t i = 0; i < keypoints.size(); i++)
     // look up the test pattern
-    patterns->compute(keypoints[i], integral_image, descriptors.ptr(i));
+    patterns->compute(keypoints[i], integral_image, descriptors.ptr((int)i));
 }
 
 }
diff --git a/modules/features2d/src/sift.cpp b/modules/features2d/src/sift.cpp
index 4cdf9207be..179097f636 100644
--- a/modules/features2d/src/sift.cpp
+++ b/modules/features2d/src/sift.cpp
@@ -1663,7 +1663,9 @@ void SIFT::operator()(const Mat& image, const Mat& mask,
         // filter points by subMask and convert the points coordinates from subImage size to image size
         KeyPointsFilter::runByPixelsMask( keypoints, subMask );
         int dx = brect.x, dy = brect.y;
-        for( vector<KeyPoint>::iterator it = keypoints.begin(); it != keypoints.end(); ++it )
+        vector<KeyPoint>::iterator it = keypoints.begin(),
+                                   end = keypoints.end();
+        for( ; it != end; ++it )
         {
             it->pt.x += dx;
             it->pt.y += dy;
@@ -1671,6 +1673,48 @@ void SIFT::operator()(const Mat& image, const Mat& mask,
     }
 }
 
+void release_features_data( CvSeq* featuresSeq )
+{
+    for( int i = 0; i < featuresSeq->total; i++ )
+    {
+        feature * ft = CV_GET_SEQ_ELEM( feature, featuresSeq, i );
+        free( ft->feature_data );
+    }
+}
+
+// Calculate orientation of features.
+// Note: calc_feature_oris() duplicates the points with several dominant orientations.
+// So if keypoints was detected by Sift feature detector then some points will be
+// duplicated twice.
+void recalculateAngles( vector<KeyPoint>& keypoints, IplImage*** gauss_pyr,
+                        int nOctaves, int nOctaveLayers )
+{
+    CvMemStorage* storage = cvCreateMemStorage( 0 );
+    CvSeq* featuresSeq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(struct feature), storage );
+
+    for( size_t i = 0; i < keypoints.size(); i++ )
+    {
+        feature ft;
+        keyPointToFeature( keypoints[i], ft, SiftParams( nOctaves, nOctaveLayers ) );
+        cvSeqPush( featuresSeq, &ft );
+    }
+
+    calc_feature_oris( featuresSeq, gauss_pyr );
+
+    keypoints.resize( featuresSeq->total );
+    for( int i = 0; i < featuresSeq->total; i++ )
+    {
+        feature * ft = CV_GET_SEQ_ELEM( feature, featuresSeq, i );
+        keypoints[i] = featureToKeyPoint( *ft );
+    }
+
+    // Remove duplicated keypoints.
+    KeyPointsFilter::removeDuplicated( keypoints );
+
+    release_features_data( featuresSeq );
+    cvReleaseMemStorage( &storage );
+}
+
 // descriptors
 void SIFT::operator()(const Mat& image, const Mat& mask,
                       vector<KeyPoint>& keypoints,
@@ -1694,42 +1738,17 @@ void SIFT::operator()(const Mat& image, const Mat& mask,
     IplImage img = fimg;
     ImagePyrData pyrImages( &img, commParams.nOctaves, commParams.nOctaveLayers, SIFT_SIGMA, SIFT_IMG_DBL );
 
-    // Calculate orientation of features.
-    // Note: calc_feature_oris() duplicates the points with several dominant orientations.
-    // So if keypoints was detected by Sift feature detector then some points will be
-    // duplicated twice.
+    if( descriptorParams.recalculateAngles )
+        recalculateAngles( keypoints, pyrImages.gauss_pyr, commParams.nOctaves, commParams.nOctaveLayers );
+
     CvMemStorage* storage = cvCreateMemStorage( 0 );
     CvSeq* featuresSeq = cvCreateSeq( 0, sizeof(CvSeq), sizeof(struct feature), storage );
 
-    if( descriptorParams.recalculateAngles )
-    {
-        for( size_t i = 0; i < keypoints.size(); i++ )
-        {
-            feature* ft = (feature*) calloc( 1, sizeof( struct feature ) );
-            keyPointToFeature( keypoints[i], *ft, SiftParams( commParams.nOctaves, commParams.nOctaveLayers ) );
-            cvSeqPush( featuresSeq, ft );
-        }
-        calc_feature_oris( featuresSeq, pyrImages.gauss_pyr );
-
-        keypoints.resize( featuresSeq->total );
-        for( int i = 0; i < featuresSeq->total; i++ )
-        {
-            feature * ft = CV_GET_SEQ_ELEM( feature, featuresSeq, i );
-            keypoints[i] = featureToKeyPoint( *ft );
-        }
-
-        // Remove duplicated keypoints.
-        KeyPointsFilter::removeDuplicated( keypoints );
-
-        // Compute descriptors.
-        cvSeqRemoveSlice( featuresSeq, cvSlice(0, featuresSeq->total) );
-    }
-
     for( size_t i = 0; i < keypoints.size(); i++ )
     {
-        feature* ft = (feature*) calloc( 1, sizeof( struct feature ) );
-        keyPointToFeature( keypoints[i], *ft, SiftParams( commParams.nOctaves, commParams.nOctaveLayers ) );
-        cvSeqPush( featuresSeq, ft );
+        feature ft;
+        keyPointToFeature( keypoints[i], ft, SiftParams( commParams.nOctaves, commParams.nOctaveLayers ) );
+        cvSeqPush( featuresSeq, &ft );
     }
     compute_descriptors( featuresSeq, pyrImages.gauss_pyr, SIFT_DESCR_WIDTH, SIFT_DESCR_HIST_BINS );
     CV_DbgAssert( (int)keypoints.size() == featuresSeq->total );
@@ -1748,5 +1767,6 @@ void SIFT::operator()(const Mat& image, const Mat& mask,
         }
     }
 
+    release_features_data( featuresSeq );
     cvReleaseMemStorage( &storage );
 }
diff --git a/modules/features2d/test/test_features2d.cpp b/modules/features2d/test/test_features2d.cpp
index 6640077a03..af26a1bf1a 100644
--- a/modules/features2d/test/test_features2d.cpp
+++ b/modules/features2d/test/test_features2d.cpp
@@ -139,8 +139,8 @@ void CV_FeatureDetectorTest::compareKeypointSets( const vector<KeyPoint>& validK
         return;
     }
 
-    int progress = 0, progressCount = validKeypoints.size() * calcKeypoints.size();
-    int badPointCount = 0, commonPointCount = max(validKeypoints.size(), calcKeypoints.size());
+    int progress = 0, progressCount = (int)(validKeypoints.size() * calcKeypoints.size());
+    int badPointCount = 0, commonPointCount = max((int)validKeypoints.size(), (int)calcKeypoints.size());
     for( size_t v = 0; v < validKeypoints.size(); v++ )
     {
         int nearestIdx = -1;
@@ -148,12 +148,12 @@ void CV_FeatureDetectorTest::compareKeypointSets( const vector<KeyPoint>& validK
 
         for( size_t c = 0; c < calcKeypoints.size(); c++ )
         {
-            progress = update_progress( progress, v*calcKeypoints.size() + c, progressCount, 0 );
+            progress = update_progress( progress, (int)(v*calcKeypoints.size() + c), progressCount, 0 );
             float curDist = (float)norm( calcKeypoints[c].pt - validKeypoints[v].pt );
             if( curDist < minDist )
             {
                 minDist = curDist;
-                nearestIdx = c;
+                nearestIdx = (int)c;
             }
         }
 
@@ -256,7 +256,7 @@ static void writeMatInBin( const Mat& mat, const string& filename )
         fwrite( (void*)&mat.rows, sizeof(int), 1, f );
         fwrite( (void*)&mat.cols, sizeof(int), 1, f );
         fwrite( (void*)&type, sizeof(int), 1, f );
-        int dataSize = mat.step * mat.rows * mat.channels();
+        int dataSize = (int)(mat.step * mat.rows * mat.channels());
         fwrite( (void*)&dataSize, sizeof(int), 1, f );
         fwrite( (void*)mat.data, 1, dataSize, f );
         fclose(f);
@@ -1047,7 +1047,7 @@ TEST( Features2d_DescriptorExtractor_SURF, regression )
 TEST( Features2d_DescriptorExtractor_ORB, regression )
 {
     // TODO adjust the parameters below
-    CV_DescriptorExtractorTest<Hamming> test( "descriptor-orb",  (CV_DescriptorExtractorTest<Hamming>::DistanceType)1.0f,
+    CV_DescriptorExtractorTest<Hamming> test( "descriptor-orb",  (CV_DescriptorExtractorTest<Hamming>::DistanceType)3.f,
                                                  DescriptorExtractor::create("ORB"), 0.010f );
     test.safe_run();
 }
@@ -1059,12 +1059,12 @@ TEST( Features2d_DescriptorExtractor_BRIEF, regression )
     test.safe_run();
 }
 
-TEST( Features2d_DescriptorExtractor_OpponentSIFT, regression )
+/*TEST( Features2d_DescriptorExtractor_OpponentSIFT, regression )
 {
     CV_DescriptorExtractorTest<L2<float> > test( "descriptor-opponent-sift", 0.18f,
                                                  DescriptorExtractor::create("OpponentSIFT"), 8.06652f  );
     test.safe_run();
-}
+}*/
 
 TEST( Features2d_DescriptorExtractor_OpponentSURF, regression )
 {
diff --git a/modules/features2d/test/test_nearestneighbors.cpp b/modules/features2d/test/test_nearestneighbors.cpp
index 01d16c8a36..0a23c525bb 100644
--- a/modules/features2d/test/test_nearestneighbors.cpp
+++ b/modules/features2d/test/test_nearestneighbors.cpp
@@ -405,14 +405,14 @@ int CV_FlannTest::radiusSearch( Mat& points, Mat& neighbors )
         // 1st way
         Mat p( 1, points.cols, CV_32FC1, points.ptr<float>(i) ),
             n( 1, neighbors.cols, CV_32SC1, neighbors.ptr<int>(i) );
-        index->radiusSearch( p, n, dist, radius, SearchParams() );
+        index->radiusSearch( p, n, dist, radius, neighbors.cols, SearchParams() );
 
         // 2nd way
         float* fltPtr = points.ptr<float>(i);
         vector<float> query( fltPtr, fltPtr + points.cols );
         vector<int> indices( neighbors1.cols, 0 );
         vector<float> dists( dist.cols, 0 );
-        index->radiusSearch( query, indices, dists, radius, SearchParams() );
+        index->radiusSearch( query, indices, dists, radius, neighbors.cols, SearchParams() );
         vector<int>::const_iterator it = indices.begin();
         for( j = 0; it != indices.end(); ++it, j++ )
             neighbors1.at<int>(i,j) = *it;
diff --git a/modules/flann/doc/flann.rst b/modules/flann/doc/flann.rst
new file mode 100644
index 0000000000..7eee435ee6
--- /dev/null
+++ b/modules/flann/doc/flann.rst
@@ -0,0 +1,9 @@
+********************************************************
+flann. Clustering and Search in Multi-Dimensional Spaces
+********************************************************
+
+.. toctree::
+    :maxdepth: 2
+
+    flann_fast_approximate_nearest_neighbor_search
+    flann_clustering
diff --git a/modules/flann/doc/flann_clustering.rst b/modules/flann/doc/flann_clustering.rst
new file mode 100644
index 0000000000..4ea53bd692
--- /dev/null
+++ b/modules/flann/doc/flann_clustering.rst
@@ -0,0 +1,18 @@
+Clustering
+==========
+
+.. highlight:: cpp
+
+flann::hierarchicalClustering<ET,DT>
+--------------------------------------------
+Clusters features using hierarchical k-means algorithm.
+
+.. ocv:function:: int flann::hierarchicalClustering<ET,DT>(const Mat& features, Mat& centers,                                      const KMeansIndexParams& params)
+
+    :param features: The points to be clustered. The matrix must have elements of type ET. 
+    
+    :param centers: The centers of the clusters obtained. The matrix must have type DT. The number of rows in this matrix represents the number of clusters desired, however, because of the way the cut in the hierarchical tree is chosen, the number of clusters computed will be the highest number of the form  ``(branching-1)*k+1``  that's lower than the number of clusters desired, where  ``branching``  is the tree's branching factor (see description of the KMeansIndexParams). 
+    
+    :param params: Parameters used in the construction of the hierarchical k-means tree 
+    
+The method clusters the given feature vectors by constructing a hierarchical k-means tree and choosing a cut in the tree that minimizes the cluster's variance. It returns the number of clusters found.
diff --git a/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst b/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst
new file mode 100644
index 0000000000..5819c02bd3
--- /dev/null
+++ b/modules/flann/doc/flann_fast_approximate_nearest_neighbor_search.rst
@@ -0,0 +1,193 @@
+Fast Approximate Nearest Neighbor Search
+========================================
+
+.. highlight:: cpp
+
+
+This section documents OpenCV's interface to the FLANN library. FLANN (Fast Library for Approximate Nearest Neighbors) is a library that contains a collection of algorithms optimized for fast nearest neighbor search in large datasets and for high dimensional features. More information about FLANN can be found in [Muja2009]_ .
+
+
+flann::Index\_
+-----------------
+
+.. ocv:class:: cv::flann::Index_
+
+The FLANN nearest neighbor index class. This class is templated with the type of elements for which the index is built.
+
+
+flann::Index_<T>::Index\_
+--------------------------
+Constructs a nearest neighbor search index for a given dataset.
+
+.. ocv:function:: flann::Index_<T>::Index_(const Mat& features, const IndexParams& params)
+    
+    :param features:  Matrix of containing the features(points) to index. The size of the matrix is ``num_features x feature_dimensionality`` and the data type of the elements in the matrix must coincide with the type of the index. 
+    
+    :param params: Structure containing the index parameters. The type of index that will be constructed depends on the type of this parameter. See the description.
+    
+The method constructs a fast search structure from a set of features using the specified algorithm with specified parameters, as defined by ``params``. ``params`` is a reference to one of the following class ``IndexParams`` descendants:
+    
+    *
+    
+       **LinearIndexParams** When passing an object of this type, the index will perform a linear, brute-force search. ::
+    
+            struct LinearIndexParams : public IndexParams
+            {
+            };
+            
+       ..
+
+    *
+    
+       **KDTreeIndexParams** When passing an object of this type the index constructed will consist of a set of randomized kd-trees which will be searched in parallel. ::
+    
+            struct KDTreeIndexParams : public IndexParams
+            {
+                KDTreeIndexParams( int trees = 4 );
+            };
+
+       ..
+    
+            * **trees** The number of parallel kd-trees to use. Good values are in the range [1..16] 
+
+    *
+    
+       **KMeansIndexParams** When passing an object of this type the index constructed will be a hierarchical k-means tree. ::
+    
+            struct KMeansIndexParams : public IndexParams
+            {
+                KMeansIndexParams(
+                    int branching = 32,
+                    int iterations = 11,
+                    flann_centers_init_t centers_init = CENTERS_RANDOM,
+                    float cb_index = 0.2 );
+            };
+    
+       ..
+    
+           * **branching**  The branching factor to use for the hierarchical k-means tree  
+    
+           * **iterations**  The maximum number of iterations to use in the k-means clustering stage when building the k-means tree. A value of -1 used here means that the k-means clustering should be iterated until convergence 
+    
+           * **centers_init** The algorithm to use for selecting the initial centers when performing a k-means clustering step. The possible values are  ``CENTERS_RANDOM``  (picks the initial cluster centers randomly),  ``CENTERS_GONZALES``  (picks the initial centers using Gonzales' algorithm) and  ``CENTERS_KMEANSPP``  (picks the initial centers using the algorithm suggested in  arthur_kmeanspp_2007 ) 
+    
+           * **cb_index** This parameter (cluster boundary index) influences the way exploration is performed in the hierarchical kmeans tree. When  ``cb_index``  is zero the next kmeans domain to be explored is choosen to be the one with the closest center. A value greater then zero also takes into account the size of the domain. 
+
+    *
+       **CompositeIndexParams** When using a parameters object of this type the index created combines the randomized kd-trees  and the hierarchical k-means tree. ::
+    
+            struct CompositeIndexParams : public IndexParams
+            {
+                CompositeIndexParams(
+                    int trees = 4,
+                    int branching = 32,
+                    int iterations = 11,
+                    flann_centers_init_t centers_init = CENTERS_RANDOM,
+                    float cb_index = 0.2 );
+            };
+            
+        ..
+
+    *
+       **AutotunedIndexParams** When passing an object of this type the index created is automatically tuned to offer  the best performance, by choosing the optimal index type (randomized kd-trees, hierarchical kmeans, linear) and parameters for the dataset provided. ::
+    
+            struct AutotunedIndexParams : public IndexParams
+            {
+                AutotunedIndexParams(
+                    float target_precision = 0.9,
+                    float build_weight = 0.01,
+                    float memory_weight = 0,
+                    float sample_fraction = 0.1 );
+            };
+    
+       ..
+    
+           * **target_precision**  Is a number between 0 and 1 specifying the percentage of the approximate nearest-neighbor searches that return the exact nearest-neighbor. Using a higher value for this parameter gives more accurate results, but the search takes longer. The optimum value usually depends on the application.  
+    
+    
+           * **build_weight**  Specifies the importance of the index build time raported to the nearest-neighbor search time. In some applications it's acceptable for the index build step to take a long time if the subsequent searches in the index can be performed very fast. In other applications it's required that the index be build as fast as possible even if that leads to slightly longer search times. 
+    
+    
+           * **memory_weight** Is used to specify the tradeoff between time (index build time and search time) and memory used by the index. A value less than 1 gives more importance to the time spent and a value greater than 1 gives more importance to the memory usage. 
+    
+    
+           * **sample_fraction** Is a number between 0 and 1 indicating what fraction of the dataset to use in the automatic parameter configuration algorithm. Running the algorithm on the full dataset gives the most accurate results, but for very large datasets can take longer than desired. In such case using just a fraction of the data helps speeding up this algorithm while still giving good approximations of the optimum parameters. 
+
+    *
+       **SavedIndexParams** This object type is used for loading a previously saved index from the disk. ::
+    
+            struct SavedIndexParams : public IndexParams
+            {
+                SavedIndexParams( std::string filename );
+            };
+    
+
+       ..
+    
+          * **filename**  The filename in which the index was saved.  
+    
+
+flann::Index_<T>::knnSearch
+----------------------------
+Performs a K-nearest neighbor search for a given query point using the index.
+
+.. ocv:function:: void flann::Index_<T>::knnSearch(const vector<T>& query, vector<int>& indices,                 vector<float>& dists, int knn, const SearchParams& params)
+
+.. ocv:function:: void flann::Index_<T>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params)
+
+    :param query: The query point 
+    
+    :param indices: Vector that will contain the indices of the K-nearest neighbors found. It must have at least knn size. 
+    
+    :param dists: Vector that will contain the distances to the K-nearest neighbors found. It must have at least knn size. 
+    
+    :param knn: Number of nearest neighbors to search for. 
+    
+    :param params:
+    
+                Search parameters ::
+        
+                      struct SearchParams {
+                              SearchParams(int checks = 32);
+                      };
+        
+                ..
+        
+                    * **checks**  The number of times the tree(s) in the index should be recursively traversed. A higher value for this parameter would give better search precision, but also take more time. If automatic configuration was used when the index was created, the number of checks required to achieve the specified precision was also computed, in which case this parameter is ignored. 
+
+
+flann::Index_<T>::radiusSearch
+--------------------------------------
+Performs a radius nearest neighbor search for a given query point.
+
+.. ocv:function:: int flann::Index_<T>::radiusSearch(const vector<T>& query, vector<int>& indices,                   vector<float>& dists, float radius, const SearchParams& params)
+
+.. ocv:function:: int flann::Index_<T>::radiusSearch(const Mat& query, Mat& indices, Mat& dists,                   float radius, const SearchParams& params)
+
+    :param query: The query point 
+    
+    :param indices: Vector that will contain the indices of the points found within the search radius in decreasing order of the distance to the query point. If the number of neighbors in the search radius is bigger than the size of this vector, the ones that don't fit in the vector are ignored.  
+    
+    :param dists: Vector that will contain the distances to the points found within the search radius 
+    
+    :param radius: The search radius 
+    
+    :param params: Search parameters 
+
+
+flann::Index_<T>::save
+------------------------------
+Saves the index to a file.
+
+.. ocv:function:: void flann::Index_<T>::save(std::string filename)
+    
+    :param filename: The file to save the index to 
+
+
+flann::Index_<T>::getIndexParameters
+--------------------------------------------
+Returns the index paramreters.
+
+.. ocv:function:: const IndexParams* flann::Index_<T>::getIndexParameters()
+
+The method is useful in the case of auto-tuned indices, when the parameters are chosen during the index construction. Then, the method can be used to retrieve the actual parameter values.
diff --git a/modules/flann/include/opencv2/flann/all_indices.h b/modules/flann/include/opencv2/flann/all_indices.h
index 898ac09980..ff53fd84c2 100644
--- a/modules/flann/include/opencv2/flann/all_indices.h
+++ b/modules/flann/include/opencv2/flann/all_indices.h
@@ -27,50 +27,129 @@
  *************************************************************************/
 
 
-#ifndef _OPENCV_ALL_INDICES_H_
-#define _OPENCV_ALL_INDICES_H_
+#ifndef OPENCV_FLANN_ALL_INDICES_H_
+#define OPENCV_FLANN_ALL_INDICES_H_
 
-#include "opencv2/flann/general.h"
+#include "general.h"
 
-#include "opencv2/flann/nn_index.h"
-#include "opencv2/flann/kdtree_index.h"
-#include "opencv2/flann/kmeans_index.h"
-#include "opencv2/flann/composite_index.h"
-#include "opencv2/flann/linear_index.h"
-#include "opencv2/flann/autotuned_index.h"
+#include "nn_index.h"
+#include "kdtree_index.h"
+#include "kdtree_single_index.h"
+#include "kmeans_index.h"
+#include "composite_index.h"
+#include "linear_index.h"
+#include "hierarchical_clustering_index.h"
+#include "lsh_index.h"
+#include "autotuned_index.h"
 
-namespace cvflann 
+
+namespace cvflann
 {
 
-template<typename T>
-NNIndex<T>* create_index_by_type(const Matrix<T>& dataset, const IndexParams& params)
+template<typename KDTreeCapability, typename VectorSpace, typename Distance>
+struct index_creator
 {
-	flann_algorithm_t index_type = params.getIndexType();
+    static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
+    {
+        flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
 
-	NNIndex<T>* nnIndex;
-	switch (index_type) {
-	case FLANN_INDEX_LINEAR:
-		nnIndex = new LinearIndex<T>(dataset, (const LinearIndexParams&)params);
-		break;
-	case FLANN_INDEX_KDTREE:
-		nnIndex = new KDTreeIndex<T>(dataset, (const KDTreeIndexParams&)params);
-		break;
-	case FLANN_INDEX_KMEANS:
-		nnIndex = new KMeansIndex<T>(dataset, (const KMeansIndexParams&)params);
-		break;
-	case FLANN_INDEX_COMPOSITE:
-		nnIndex = new CompositeIndex<T>(dataset, (const CompositeIndexParams&) params);
-		break;
-	case FLANN_INDEX_AUTOTUNED:
-		nnIndex = new AutotunedIndex<T>(dataset, (const AutotunedIndexParams&) params);
-		break;
-	default:
-		throw FLANNException("Unknown index type");
-	}
+        NNIndex<Distance>* nnIndex;
+        switch (index_type) {
+        case FLANN_INDEX_LINEAR:
+            nnIndex = new LinearIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_KDTREE_SINGLE:
+            nnIndex = new KDTreeSingleIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_KDTREE:
+            nnIndex = new KDTreeIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_KMEANS:
+            nnIndex = new KMeansIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_COMPOSITE:
+            nnIndex = new CompositeIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_AUTOTUNED:
+            nnIndex = new AutotunedIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_HIERARCHICAL:
+            nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_LSH:
+            nnIndex = new LshIndex<Distance>(dataset, params, distance);
+            break;
+        default:
+            throw FLANNException("Unknown index type");
+        }
 
-	return nnIndex;
+        return nnIndex;
+    }
+};
+
+template<typename VectorSpace, typename Distance>
+struct index_creator<False,VectorSpace,Distance>
+{
+    static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
+    {
+        flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
+
+        NNIndex<Distance>* nnIndex;
+        switch (index_type) {
+        case FLANN_INDEX_LINEAR:
+            nnIndex = new LinearIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_KMEANS:
+            nnIndex = new KMeansIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_HIERARCHICAL:
+            nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_LSH:
+            nnIndex = new LshIndex<Distance>(dataset, params, distance);
+            break;
+        default:
+            throw FLANNException("Unknown index type");
+        }
+
+        return nnIndex;
+    }
+};
+
+template<typename Distance>
+struct index_creator<False,False,Distance>
+{
+    static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
+    {
+        flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
+
+        NNIndex<Distance>* nnIndex;
+        switch (index_type) {
+        case FLANN_INDEX_LINEAR:
+            nnIndex = new LinearIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_HIERARCHICAL:
+            nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
+            break;
+        case FLANN_INDEX_LSH:
+            nnIndex = new LshIndex<Distance>(dataset, params, distance);
+            break;
+        default:
+            throw FLANNException("Unknown index type");
+        }
+
+        return nnIndex;
+    }
+};
+
+template<typename Distance>
+NNIndex<Distance>* create_index_by_type(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
+{
+    return index_creator<typename Distance::is_kdtree_distance,
+                         typename Distance::is_vector_space_distance,
+                         Distance>::create(dataset, params,distance);
 }
 
-} //namespace cvflann
+}
 
-#endif /* _OPENCV_ALL_INDICES_H_ */
+#endif /* OPENCV_FLANN_ALL_INDICES_H_ */
diff --git a/modules/flann/include/opencv2/flann/allocator.h b/modules/flann/include/opencv2/flann/allocator.h
index 0215ac6141..6ca44fcc83 100644
--- a/modules/flann/include/opencv2/flann/allocator.h
+++ b/modules/flann/include/opencv2/flann/allocator.h
@@ -28,12 +28,13 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_ALLOCATOR_H_
-#define _OPENCV_ALLOCATOR_H_
+#ifndef OPENCV_FLANN_ALLOCATOR_H_
+#define OPENCV_FLANN_ALLOCATOR_H_
 
 #include <stdlib.h>
 #include <stdio.h>
 
+
 namespace cvflann
 {
 
@@ -47,8 +48,8 @@ namespace cvflann
 template <typename T>
 T* allocate(size_t count = 1)
 {
-	T* mem = (T*) ::malloc(sizeof(T)*count);
-	return mem;
+    T* mem = (T*) ::malloc(sizeof(T)*count);
+    return mem;
 }
 
 
@@ -70,118 +71,118 @@ T* allocate(size_t count = 1)
 const size_t     WORDSIZE=16;
 const  size_t     BLOCKSIZE=8192;
 
-class CV_EXPORTS PooledAllocator
+class PooledAllocator
 {
-	/* We maintain memory alignment to word boundaries by requiring that all
-		allocations be in multiples of the machine wordsize.  */
-	  /* Size of machine word in bytes.  Must be power of 2. */
-	/* Minimum number of bytes requested at a time from	the system.  Must be multiple of WORDSIZE. */
+    /* We maintain memory alignment to word boundaries by requiring that all
+        allocations be in multiples of the machine wordsize.  */
+    /* Size of machine word in bytes.  Must be power of 2. */
+    /* Minimum number of bytes requested at a time from	the system.  Must be multiple of WORDSIZE. */
 
 
-	int 	remaining;  /* Number of bytes left in current block of storage. */
-	void*	base;     /* Pointer to base of current block of storage. */
-	void*	loc;      /* Current location in block to next allocate memory. */
-	int 	blocksize;
+    int     remaining;  /* Number of bytes left in current block of storage. */
+    void*   base;     /* Pointer to base of current block of storage. */
+    void*   loc;      /* Current location in block to next allocate memory. */
+    int     blocksize;
 
 
 public:
-	int 	usedMemory;
-	int 	wastedMemory;
+    int     usedMemory;
+    int     wastedMemory;
 
-	/**
-		Default constructor. Initializes a new pool.
-	*/
-	PooledAllocator(int blocksize = BLOCKSIZE)
-	{
-    	this->blocksize = blocksize;
-		remaining = 0;
-		base = NULL;
+    /**
+        Default constructor. Initializes a new pool.
+     */
+    PooledAllocator(int blocksize = BLOCKSIZE)
+    {
+        this->blocksize = blocksize;
+        remaining = 0;
+        base = NULL;
 
-		usedMemory = 0;
-		wastedMemory = 0;
-	}
+        usedMemory = 0;
+        wastedMemory = 0;
+    }
 
-	/**
-	 * Destructor. Frees all the memory allocated in this pool.
-	 */
- 	~PooledAllocator()
-	{
-		void *prev;
+    /**
+     * Destructor. Frees all the memory allocated in this pool.
+     */
+    ~PooledAllocator()
+    {
+        void* prev;
 
-		while (base != NULL) {
-			prev = *((void **) base);  /* Get pointer to prev block. */
-			::free(base);
-			base = prev;
-		}
-	}
+        while (base != NULL) {
+            prev = *((void**) base); /* Get pointer to prev block. */
+            ::free(base);
+            base = prev;
+        }
+    }
 
-	/**
-	 * Returns a pointer to a piece of new memory of the given size in bytes
-	 * allocated from the pool.
-	 */
-	void* allocateBytes(int size)
-	{
-		int blocksize;
+    /**
+     * Returns a pointer to a piece of new memory of the given size in bytes
+     * allocated from the pool.
+     */
+    void* allocateMemory(int size)
+    {
+        int blocksize;
 
-		/* Round size up to a multiple of wordsize.  The following expression
-			only works for WORDSIZE that is a power of 2, by masking last bits of
-			incremented size to zero.
-		*/
-		size = (size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);
+        /* Round size up to a multiple of wordsize.  The following expression
+            only works for WORDSIZE that is a power of 2, by masking last bits of
+            incremented size to zero.
+         */
+        size = (size + (WORDSIZE - 1)) & ~(WORDSIZE - 1);
 
-		/* Check whether a new block must be allocated.  Note that the first word
-			of a block is reserved for a pointer to the previous block.
-		*/
-		if (size > remaining) {
+        /* Check whether a new block must be allocated.  Note that the first word
+            of a block is reserved for a pointer to the previous block.
+         */
+        if (size > remaining) {
 
-			wastedMemory += remaining;
+            wastedMemory += remaining;
 
-		/* Allocate new storage. */
-			blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
-						size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;
+            /* Allocate new storage. */
+            blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
+                        size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;
 
-			// use the standard C malloc to allocate memory
-			void* m = ::malloc(blocksize);
-			if (!m) {
+            // use the standard C malloc to allocate memory
+            void* m = ::malloc(blocksize);
+            if (!m) {
                 fprintf(stderr,"Failed to allocate memory.\n");
-                exit(1);
-			}
+                return NULL;
+            }
 
-			/* Fill first word of new block with pointer to previous block. */
-			((void **) m)[0] = base;
-			base = m;
+            /* Fill first word of new block with pointer to previous block. */
+            ((void**) m)[0] = base;
+            base = m;
 
-			int shift = 0;
-			//int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);
+            int shift = 0;
+            //int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);
 
-			remaining = blocksize - sizeof(void*) - shift;
-			loc = ((char*)m + sizeof(void*) + shift);
-		}
-		void* rloc = loc;
-		loc = (char*)loc + size;
-		remaining -= size;
+            remaining = blocksize - sizeof(void*) - shift;
+            loc = ((char*)m + sizeof(void*) + shift);
+        }
+        void* rloc = loc;
+        loc = (char*)loc + size;
+        remaining -= size;
 
-		usedMemory += size;
+        usedMemory += size;
 
-		return rloc;
-	}
+        return rloc;
+    }
 
-	/**
-	 * Allocates (using this pool) a generic type T.
-	 *
-	 * Params:
-	 *     count = number of instances to allocate.
-	 * Returns: pointer (of type T*) to memory buffer
-	 */
+    /**
+     * Allocates (using this pool) a generic type T.
+     *
+     * Params:
+     *     count = number of instances to allocate.
+     * Returns: pointer (of type T*) to memory buffer
+     */
     template <typename T>
-	T* allocate(size_t count = 1)
-	{
-		T* mem = (T*) this->allocateBytes((int)(sizeof(T)*count));
-		return mem;
-	}
+    T* allocate(size_t count = 1)
+    {
+        T* mem = (T*) this->allocateMemory((int)(sizeof(T)*count));
+        return mem;
+    }
 
 };
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_ALLOCATOR_H_
+#endif //OPENCV_FLANN_ALLOCATOR_H_
diff --git a/modules/flann/include/opencv2/flann/any.h b/modules/flann/include/opencv2/flann/any.h
new file mode 100644
index 0000000000..46e11160ce
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/any.h
@@ -0,0 +1,284 @@
+#ifndef OPENCV_FLANN_ANY_H_
+#define OPENCV_FLANN_ANY_H_
+/*
+ * (C) Copyright Christopher Diggins 2005-2011
+ * (C) Copyright Pablo Aguilar 2005
+ * (C) Copyright Kevlin Henney 2001
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ *
+ * Adapted for FLANN by Marius Muja
+ */
+
+#include <stdexcept>
+#include <ostream>
+#include <typeinfo>
+
+namespace cdiggins
+{
+
+namespace anyimpl
+{
+
+struct bad_any_cast
+{
+};
+
+struct empty_any
+{
+};
+
+struct base_any_policy
+{
+    virtual void static_delete(void** x) = 0;
+    virtual void copy_from_value(void const* src, void** dest) = 0;
+    virtual void clone(void* const* src, void** dest) = 0;
+    virtual void move(void* const* src, void** dest) = 0;
+    virtual void* get_value(void** src) = 0;
+    virtual size_t get_size() = 0;
+    virtual const std::type_info& type() = 0;
+    virtual void print(std::ostream& out, void* const* src) = 0;
+};
+
+template<typename T>
+struct typed_base_any_policy : base_any_policy
+{
+    virtual size_t get_size() { return sizeof(T); }
+    virtual const std::type_info& type() { return typeid(T); }
+
+};
+
+template<typename T>
+struct small_any_policy : typed_base_any_policy<T>
+{
+    virtual void static_delete(void**) { }
+    virtual void copy_from_value(void const* src, void** dest)
+    {
+        new (dest) T(* reinterpret_cast<T const*>(src));
+    }
+    virtual void clone(void* const* src, void** dest) { *dest = *src; }
+    virtual void move(void* const* src, void** dest) { *dest = *src; }
+    virtual void* get_value(void** src) { return reinterpret_cast<void*>(src); }
+    virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(src); }
+};
+
+template<typename T>
+struct big_any_policy : typed_base_any_policy<T>
+{
+    virtual void static_delete(void** x)
+    {
+        if (* x) delete (* reinterpret_cast<T**>(x)); *x = NULL;
+    }
+    virtual void copy_from_value(void const* src, void** dest)
+    {
+        *dest = new T(*reinterpret_cast<T const*>(src));
+    }
+    virtual void clone(void* const* src, void** dest)
+    {
+        *dest = new T(**reinterpret_cast<T* const*>(src));
+    }
+    virtual void move(void* const* src, void** dest)
+    {
+        (*reinterpret_cast<T**>(dest))->~T();
+        **reinterpret_cast<T**>(dest) = **reinterpret_cast<T* const*>(src);
+    }
+    virtual void* get_value(void** src) { return *src; }
+    virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(*src); }
+};
+
+template<typename T>
+struct choose_policy
+{
+    typedef big_any_policy<T> type;
+};
+
+template<typename T>
+struct choose_policy<T*>
+{
+    typedef small_any_policy<T*> type;
+};
+
+struct any;
+
+/// Choosing the policy for an any type is illegal, but should never happen.
+/// This is designed to throw a compiler error.
+template<>
+struct choose_policy<any>
+{
+    typedef void type;
+};
+
+/// Specializations for small types.
+#define SMALL_POLICY(TYPE) \
+    template<> \
+    struct choose_policy<TYPE> { typedef small_any_policy<TYPE> type; \
+    };
+
+SMALL_POLICY(signed char);
+SMALL_POLICY(unsigned char);
+SMALL_POLICY(signed short);
+SMALL_POLICY(unsigned short);
+SMALL_POLICY(signed int);
+SMALL_POLICY(unsigned int);
+SMALL_POLICY(signed long);
+SMALL_POLICY(unsigned long);
+SMALL_POLICY(float);
+SMALL_POLICY(bool);
+
+#undef SMALL_POLICY
+
+/// This function will return a different policy for each type.
+template<typename T>
+base_any_policy* get_policy()
+{
+    static typename choose_policy<T>::type policy;
+    return &policy;
+}
+} // namespace anyimpl
+
+struct any
+{
+private:
+    // fields
+    anyimpl::base_any_policy* policy;
+    void* object;
+
+public:
+    /// Initializing constructor.
+    template <typename T>
+    any(const T& x)
+        : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
+    {
+        assign(x);
+    }
+
+    /// Empty constructor.
+    any()
+        : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
+    { }
+
+    /// Special initializing constructor for string literals.
+    any(const char* x)
+        : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
+    {
+        assign(x);
+    }
+
+    /// Copy constructor.
+    any(const any& x)
+        : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
+    {
+        assign(x);
+    }
+
+    /// Destructor.
+    ~any()
+    {
+        policy->static_delete(&object);
+    }
+
+    /// Assignment function from another any.
+    any& assign(const any& x)
+    {
+        reset();
+        policy = x.policy;
+        policy->clone(&x.object, &object);
+        return *this;
+    }
+
+    /// Assignment function.
+    template <typename T>
+    any& assign(const T& x)
+    {
+        reset();
+        policy = anyimpl::get_policy<T>();
+        policy->copy_from_value(&x, &object);
+        return *this;
+    }
+
+    /// Assignment operator.
+    template<typename T>
+    any& operator=(const T& x)
+    {
+        return assign(x);
+    }
+
+    /// Assignment operator, specialed for literal strings.
+    /// They have types like const char [6] which don't work as expected.
+    any& operator=(const char* x)
+    {
+        return assign(x);
+    }
+
+    /// Utility functions
+    any& swap(any& x)
+    {
+        std::swap(policy, x.policy);
+        std::swap(object, x.object);
+        return *this;
+    }
+
+    /// Cast operator. You can only cast to the original type.
+    template<typename T>
+    T& cast()
+    {
+        if (policy->type() != typeid(T)) throw anyimpl::bad_any_cast();
+        T* r = reinterpret_cast<T*>(policy->get_value(&object));
+        return *r;
+    }
+
+    /// Cast operator. You can only cast to the original type.
+    template<typename T>
+    const T& cast() const
+    {
+        if (policy->type() != typeid(T)) throw anyimpl::bad_any_cast();
+        void* obj = const_cast<void*>(object);
+        T* r = reinterpret_cast<T*>(policy->get_value(&obj));
+        return *r;
+    }
+
+    /// Returns true if the any contains no value.
+    bool empty() const
+    {
+        return policy->type() == typeid(anyimpl::empty_any);
+    }
+
+    /// Frees any allocated memory, and sets the value to NULL.
+    void reset()
+    {
+        policy->static_delete(&object);
+        policy = anyimpl::get_policy<anyimpl::empty_any>();
+    }
+
+    /// Returns true if the two types are the same.
+    bool compatible(const any& x) const
+    {
+        return policy->type() == x.policy->type();
+    }
+
+    /// Returns if the type is compatible with the policy
+    template<typename T>
+    bool has_type()
+    {
+        return policy->type() == typeid(T);
+    }
+
+    const std::type_info& type() const
+    {
+        return policy->type();
+    }
+
+    friend std::ostream& operator <<(std::ostream& out, const any& any_val);
+};
+
+inline std::ostream& operator <<(std::ostream& out, const any& any_val)
+{
+    any_val.policy->print(out,&any_val.object);
+    return out;
+}
+
+}
+
+#endif // OPENCV_FLANN_ANY_H_
diff --git a/modules/flann/include/opencv2/flann/autotuned_index.h b/modules/flann/include/opencv2/flann/autotuned_index.h
index 0e19f1dc76..8d531753e0 100644
--- a/modules/flann/include/opencv2/flann/autotuned_index.h
+++ b/modules/flann/include/opencv2/flann/autotuned_index.h
@@ -27,216 +27,204 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
+#ifndef OPENCV_FLANN_AUTOTUNED_INDEX_H_
+#define OPENCV_FLANN_AUTOTUNED_INDEX_H_
 
-#ifndef _OPENCV_AUTOTUNEDINDEX_H_
-#define _OPENCV_AUTOTUNEDINDEX_H_
-
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
-#include "opencv2/flann/ground_truth.h"
-#include "opencv2/flann/index_testing.h"
-#include "opencv2/flann/sampling.h"
-#include "opencv2/flann/all_indices.h"
+#include "general.h"
+#include "nn_index.h"
+#include "ground_truth.h"
+#include "index_testing.h"
+#include "sampling.h"
+#include "kdtree_index.h"
+#include "kdtree_single_index.h"
+#include "kmeans_index.h"
+#include "composite_index.h"
+#include "linear_index.h"
+#include "logger.h"
 
 namespace cvflann
 {
 
-struct AutotunedIndexParams : public IndexParams {
-	AutotunedIndexParams( float target_precision_ = 0.8, float build_weight_ = 0.01,
-			float memory_weight_ = 0, float sample_fraction_ = 0.1) :
-		IndexParams(FLANN_INDEX_AUTOTUNED),
-		target_precision(target_precision_),
-		build_weight(build_weight_),
-		memory_weight(memory_weight_),
-		sample_fraction(sample_fraction_) {};
+template<typename Distance>
+NNIndex<Distance>* create_index_by_type(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance);
 
-	float target_precision;    // precision desired (used for autotuning, -1 otherwise)
-	float build_weight;        // build tree time weighting factor
-	float memory_weight;       // index memory weighting factor
-    float sample_fraction;     // what fraction of the dataset to use for autotuning
 
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-		logger().info("logger(). precision: %g\n", target_precision);
-		logger().info("Build weight: %g\n", build_weight);
-		logger().info("Memory weight: %g\n", memory_weight);
-		logger().info("Sample fraction: %g\n", sample_fraction);
-	}
+struct AutotunedIndexParams : public IndexParams
+{
+    AutotunedIndexParams(float target_precision = 0.8, float build_weight = 0.01, float memory_weight = 0, float sample_fraction = 0.1)
+    {
+        (*this)["algorithm"] = FLANN_INDEX_AUTOTUNED;
+        // precision desired (used for autotuning, -1 otherwise)
+        (*this)["target_precision"] = target_precision;
+        // build tree time weighting factor
+        (*this)["build_weight"] = build_weight;
+        // index memory weighting factor
+        (*this)["memory_weight"] = memory_weight;
+        // what fraction of the dataset to use for autotuning
+        (*this)["sample_fraction"] = sample_fraction;
+    }
 };
 
 
-template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
-class AutotunedIndex : public NNIndex<ELEM_TYPE>
+template <typename Distance>
+class AutotunedIndex : public NNIndex<Distance>
 {
-	NNIndex<ELEM_TYPE>* bestIndex;
-
-	IndexParams* bestParams;
-	SearchParams bestSearchParams;
-
-    Matrix<ELEM_TYPE> sampledDataset;
-    Matrix<ELEM_TYPE> testDataset;
-    Matrix<int> gt_matches;
-
-    float speedup;
-
-	/**
-	 * The dataset used by this index
-	 */
-    const Matrix<ELEM_TYPE> dataset;
-
-    /**
-     * Index parameters
-     */
-    const AutotunedIndexParams& index_params;
-
-	AutotunedIndex& operator=(const AutotunedIndex&);
-	AutotunedIndex(const AutotunedIndex&);
-
 public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
 
-    AutotunedIndex(const Matrix<ELEM_TYPE>& inputData, const AutotunedIndexParams& params = AutotunedIndexParams() ) :
-    	dataset(inputData), index_params(params)
-	{
-        bestIndex = NULL;
-        bestParams = NULL;
-	}
+    AutotunedIndex(const Matrix<ElementType>& inputData, const IndexParams& params = AutotunedIndexParams(), Distance d = Distance()) :
+        dataset_(inputData), distance_(d)
+    {
+        target_precision_ = get_param(params, "target_precision",0.8f);
+        build_weight_ =  get_param(params,"build_weight", 0.01f);
+        memory_weight_ = get_param(params, "memory_weight", 0.0f);
+        sample_fraction_ = get_param(params,"sample_fraction", 0.1f);
+        bestIndex_ = NULL;
+    }
+
+    AutotunedIndex(const AutotunedIndex&);
+    AutotunedIndex& operator=(const AutotunedIndex&);
 
     virtual ~AutotunedIndex()
     {
-    	if (bestIndex!=NULL) {
-    		delete bestIndex;
-    	}
-    	if (bestParams!=NULL) {
-    		delete bestParams;
-    	}
-    };
+        if (bestIndex_ != NULL) {
+            delete bestIndex_;
+            bestIndex_ = NULL;
+        }
+    }
 
     /**
-		Method responsible with building the index.
-	*/
-	virtual void buildIndex()
-	{
-		bestParams = estimateBuildParams();
-		logger().info("----------------------------------------------------\n");
-		logger().info("Autotuned parameters:\n");
-		bestParams->print();
-		logger().info("----------------------------------------------------\n");
-    	flann_algorithm_t index_type = bestParams->getIndexType();
-    	switch (index_type) {
-    	case FLANN_INDEX_LINEAR:
-    		bestIndex = new LinearIndex<ELEM_TYPE>(dataset, (const LinearIndexParams&)*bestParams);
-    		break;
-    	case FLANN_INDEX_KDTREE:
-    		bestIndex = new KDTreeIndex<ELEM_TYPE>(dataset, (const KDTreeIndexParams&)*bestParams);
-    		break;
-    	case FLANN_INDEX_KMEANS:
-    		bestIndex = new KMeansIndex<ELEM_TYPE>(dataset, (const KMeansIndexParams&)*bestParams);
-    		break;
-    	default:
-    		throw FLANNException("Unknown algorithm choosen by the autotuning, most likely a bug.");
-    	}
-		bestIndex->buildIndex();
-		speedup = estimateSearchParams(bestSearchParams);
-	}
+     *          Method responsible with building the index.
+     */
+    virtual void buildIndex()
+    {
+        bestParams_ = estimateBuildParams();
+        Logger::info("----------------------------------------------------\n");
+        Logger::info("Autotuned parameters:\n");
+        print_params(bestParams_);
+        Logger::info("----------------------------------------------------\n");
+
+        bestIndex_ = create_index_by_type(dataset_, bestParams_, distance_);
+        bestIndex_->buildIndex();
+        speedup_ = estimateSearchParams(bestSearchParams_);
+        Logger::info("----------------------------------------------------\n");
+        Logger::info("Search parameters:\n");
+        print_params(bestSearchParams_);
+        Logger::info("----------------------------------------------------\n");
+    }
 
     /**
-        Saves the index to a stream
-    */
+     *  Saves the index to a stream
+     */
     virtual void saveIndex(FILE* stream)
     {
-    	save_value(stream, (int)bestIndex->getType());
-    	bestIndex->saveIndex(stream);
-    	save_value(stream, bestSearchParams);
+        save_value(stream, (int)bestIndex_->getType());
+        bestIndex_->saveIndex(stream);
+        save_value(stream, get_param<int>(bestSearchParams_, "checks"));
     }
 
     /**
-        Loads the index from a stream
-    */
+     *  Loads the index from a stream
+     */
     virtual void loadIndex(FILE* stream)
     {
-    	int index_type;
-    	load_value(stream,index_type);
-    	IndexParams* params = ParamsFactory_instance().create((flann_algorithm_t)index_type);
-    	bestIndex = create_index_by_type(dataset, *params);
-    	bestIndex->loadIndex(stream);
-    	load_value(stream, bestSearchParams);
+        int index_type;
+
+        load_value(stream, index_type);
+        IndexParams params;
+        params["algorithm"] = (flann_algorithm_t)index_type;
+        bestIndex_ = create_index_by_type<Distance>(dataset_, params, distance_);
+        bestIndex_->loadIndex(stream);
+        int checks;
+        load_value(stream, checks);
+        bestSearchParams_["checks"] = checks;
     }
 
-	/**
-		Method that searches for nearest-neighbors
-	*/
-	virtual void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams)
-	{
-		if (searchParams.checks==-2) {
-			bestIndex->findNeighbors(result, vec, bestSearchParams);
-		}
-		else {
-			bestIndex->findNeighbors(result, vec, searchParams);
-		}
-	}
+    /**
+     *      Method that searches for nearest-neighbors
+     */
+    virtual void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+    {
+        int checks = get_param<int>(searchParams,"checks",FLANN_CHECKS_AUTOTUNED);
+        if (checks == FLANN_CHECKS_AUTOTUNED) {
+            bestIndex_->findNeighbors(result, vec, bestSearchParams_);
+        }
+        else {
+            bestIndex_->findNeighbors(result, vec, searchParams);
+        }
+    }
 
 
-	const IndexParams* getParameters() const
-	{
-		return bestIndex->getParameters();
-	}
+    IndexParams getParameters() const
+    {
+        return bestIndex_->getParameters();
+    }
 
+    SearchParams getSearchParameters() const
+    {
+        return bestSearchParams_;
+    }
 
-	/**
-		Number of features in this index.
-	*/
-	virtual size_t size() const
-	{
-		return bestIndex->size();
-	}
+    float getSpeedup() const
+    {
+        return speedup_;
+    }
 
-	/**
-		The length of each vector in this index.
-	*/
-	virtual size_t veclen() const
-	{
-		return bestIndex->veclen();
-	}
-
-	/**
-	 The amount of memory (in bytes) this index uses.
-	*/
- 	virtual int usedMemory() const
- 	{
- 		return bestIndex->usedMemory();
- 	}
 
     /**
-    * Algorithm name
-    */
+     *      Number of features in this index.
+     */
+    virtual size_t size() const
+    {
+        return bestIndex_->size();
+    }
+
+    /**
+     *  The length of each vector in this index.
+     */
+    virtual size_t veclen() const
+    {
+        return bestIndex_->veclen();
+    }
+
+    /**
+     * The amount of memory (in bytes) this index uses.
+     */
+    virtual int usedMemory() const
+    {
+        return bestIndex_->usedMemory();
+    }
+
+    /**
+     * Algorithm name
+     */
     virtual flann_algorithm_t getType() const
     {
-    	return FLANN_INDEX_AUTOTUNED;
+        return FLANN_INDEX_AUTOTUNED;
     }
 
 private:
 
-    struct CostData {
+    struct CostData
+    {
         float searchTimeCost;
         float buildTimeCost;
-        float timeCost;
         float memoryCost;
         float totalCost;
+        IndexParams params;
     };
 
-    typedef std::pair<CostData, KDTreeIndexParams> KDTreeCostData;
-    typedef std::pair<CostData, KMeansIndexParams> KMeansCostData;
-
-
-    void evaluate_kmeans(CostData& cost, const KMeansIndexParams& kmeans_params)
+    void evaluate_kmeans(CostData& cost)
     {
         StartStopTimer t;
         int checks;
         const int nn = 1;
 
-        logger().info("KMeansTree using params: max_iterations=%d, branching=%d\n", kmeans_params.iterations, kmeans_params.branching);
-        KMeansIndex<ELEM_TYPE> kmeans(sampledDataset, kmeans_params);
+        Logger::info("KMeansTree using params: max_iterations=%d, branching=%d\n",
+                     get_param<int>(cost.params,"iterations"),
+                     get_param<int>(cost.params,"branching"));
+        KMeansIndex<Distance> kmeans(sampledDataset_, cost.params, distance_);
         // measure index build time
         t.start();
         kmeans.buildIndex();
@@ -244,25 +232,24 @@ private:
         float buildTime = (float)t.value;
 
         // measure search time
-        float searchTime = test_index_precision(kmeans, sampledDataset, testDataset, gt_matches, index_params.target_precision, checks, nn);;
+        float searchTime = test_index_precision(kmeans, sampledDataset_, testDataset_, gt_matches_, target_precision_, checks, distance_, nn);
 
-        float datasetMemory = (float)(sampledDataset.rows*sampledDataset.cols*sizeof(float));
-        cost.memoryCost = (kmeans.usedMemory()+datasetMemory)/datasetMemory;
+        float datasetMemory = float(sampledDataset_.rows * sampledDataset_.cols * sizeof(float));
+        cost.memoryCost = (kmeans.usedMemory() + datasetMemory) / datasetMemory;
         cost.searchTimeCost = searchTime;
         cost.buildTimeCost = buildTime;
-        cost.timeCost = (buildTime*index_params.build_weight+searchTime);
-        logger().info("KMeansTree buildTime=%g, searchTime=%g, timeCost=%g, buildTimeFactor=%g\n",buildTime, searchTime, cost.timeCost, index_params.build_weight);
+        Logger::info("KMeansTree buildTime=%g, searchTime=%g, build_weight=%g\n", buildTime, searchTime, build_weight_);
     }
 
 
-     void evaluate_kdtree(CostData& cost, const KDTreeIndexParams& kdtree_params)
+    void evaluate_kdtree(CostData& cost)
     {
         StartStopTimer t;
         int checks;
         const int nn = 1;
 
-        logger().info("KDTree using params: trees=%d\n",kdtree_params.trees);
-        KDTreeIndex<ELEM_TYPE> kdtree(sampledDataset, kdtree_params);
+        Logger::info("KDTree using params: trees=%d\n", get_param<int>(cost.params,"trees"));
+        KDTreeIndex<Distance> kdtree(sampledDataset_, cost.params, distance_);
 
         t.start();
         kdtree.buildIndex();
@@ -270,267 +257,220 @@ private:
         float buildTime = (float)t.value;
 
         //measure search time
-        float searchTime = test_index_precision(kdtree, sampledDataset, testDataset, gt_matches, index_params.target_precision, checks, nn);
+        float searchTime = test_index_precision(kdtree, sampledDataset_, testDataset_, gt_matches_, target_precision_, checks, distance_, nn);
 
-        float datasetMemory = (float)(sampledDataset.rows*sampledDataset.cols*sizeof(float));
-        cost.memoryCost = (kdtree.usedMemory()+datasetMemory)/datasetMemory;
+        float datasetMemory = float(sampledDataset_.rows * sampledDataset_.cols * sizeof(float));
+        cost.memoryCost = (kdtree.usedMemory() + datasetMemory) / datasetMemory;
         cost.searchTimeCost = searchTime;
         cost.buildTimeCost = buildTime;
-        cost.timeCost = (buildTime*index_params.build_weight+searchTime);
-        logger().info("KDTree buildTime=%g, searchTime=%g, timeCost=%g\n",buildTime, searchTime, cost.timeCost);
+        Logger::info("KDTree buildTime=%g, searchTime=%g\n", buildTime, searchTime);
     }
 
 
-//    struct KMeansSimpleDownhillFunctor {
-//
-//        Autotune& autotuner;
-//        KMeansSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {};
-//
-//        float operator()(int* params) {
-//
-//            float maxFloat = numeric_limits<float>::max();
-//
-//            if (params[0]<2) return maxFloat;
-//            if (params[1]<0) return maxFloat;
-//
-//            CostData c;
-//            c.params["algorithm"] = KMEANS;
-//            c.params["centers-init"] = CENTERS_RANDOM;
-//            c.params["branching"] = params[0];
-//            c.params["max-iterations"] = params[1];
-//
-//            autotuner.evaluate_kmeans(c);
-//
-//            return c.timeCost;
-//
-//        }
-//    };
-//
-//    struct KDTreeSimpleDownhillFunctor {
-//
-//        Autotune& autotuner;
-//        KDTreeSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {};
-//
-//        float operator()(int* params) {
-//            float maxFloat = numeric_limits<float>::max();
-//
-//            if (params[0]<1) return maxFloat;
-//
-//            CostData c;
-//            c.params["algorithm"] = KDTREE;
-//            c.params["trees"] = params[0];
-//
-//            autotuner.evaluate_kdtree(c);
-//
-//            return c.timeCost;
-//
-//        }
-//    };
+    //    struct KMeansSimpleDownhillFunctor {
+    //
+    //        Autotune& autotuner;
+    //        KMeansSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {};
+    //
+    //        float operator()(int* params) {
+    //
+    //            float maxFloat = numeric_limits<float>::max();
+    //
+    //            if (params[0]<2) return maxFloat;
+    //            if (params[1]<0) return maxFloat;
+    //
+    //            CostData c;
+    //            c.params["algorithm"] = KMEANS;
+    //            c.params["centers-init"] = CENTERS_RANDOM;
+    //            c.params["branching"] = params[0];
+    //            c.params["max-iterations"] = params[1];
+    //
+    //            autotuner.evaluate_kmeans(c);
+    //
+    //            return c.timeCost;
+    //
+    //        }
+    //    };
+    //
+    //    struct KDTreeSimpleDownhillFunctor {
+    //
+    //        Autotune& autotuner;
+    //        KDTreeSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {};
+    //
+    //        float operator()(int* params) {
+    //            float maxFloat = numeric_limits<float>::max();
+    //
+    //            if (params[0]<1) return maxFloat;
+    //
+    //            CostData c;
+    //            c.params["algorithm"] = KDTREE;
+    //            c.params["trees"] = params[0];
+    //
+    //            autotuner.evaluate_kdtree(c);
+    //
+    //            return c.timeCost;
+    //
+    //        }
+    //    };
 
 
 
-    KMeansCostData optimizeKMeans()
+    void optimizeKMeans(std::vector<CostData>& costs)
     {
-        logger().info("KMEANS, Step 1: Exploring parameter space\n");
+        Logger::info("KMEANS, Step 1: Exploring parameter space\n");
 
         // explore kmeans parameters space using combinations of the parameters below
         int maxIterations[] = { 1, 5, 10, 15 };
         int branchingFactors[] = { 16, 32, 64, 128, 256 };
 
-        int kmeansParamSpaceSize = ARRAY_LEN(maxIterations)*ARRAY_LEN(branchingFactors);
-
-        std::vector<KMeansCostData> kmeansCosts(kmeansParamSpaceSize);
-
-//        CostData* kmeansCosts = new CostData[kmeansParamSpaceSize];
+        int kmeansParamSpaceSize = FLANN_ARRAY_LEN(maxIterations) * FLANN_ARRAY_LEN(branchingFactors);
+        costs.reserve(costs.size() + kmeansParamSpaceSize);
 
         // evaluate kmeans for all parameter combinations
-        int cnt = 0;
-        for (size_t i=0; i<ARRAY_LEN(maxIterations); ++i) {
-            for (size_t j=0; j<ARRAY_LEN(branchingFactors); ++j) {
+        for (size_t i = 0; i < FLANN_ARRAY_LEN(maxIterations); ++i) {
+            for (size_t j = 0; j < FLANN_ARRAY_LEN(branchingFactors); ++j) {
+                CostData cost;
+                cost.params["algorithm"] = FLANN_INDEX_KMEANS;
+                cost.params["centers_init"] = FLANN_CENTERS_RANDOM;
+                cost.params["iterations"] = maxIterations[i];
+                cost.params["branching"] = branchingFactors[j];
 
-            	kmeansCosts[cnt].second.centers_init = FLANN_CENTERS_RANDOM;
-            	kmeansCosts[cnt].second.iterations = maxIterations[i];
-            	kmeansCosts[cnt].second.branching = branchingFactors[j];
-
-                evaluate_kmeans(kmeansCosts[cnt].first, kmeansCosts[cnt].second);
-
-                int k = cnt;
-                // order by time cost
-                while (k>0 && kmeansCosts[k].first.timeCost < kmeansCosts[k-1].first.timeCost) {
-                    swap(kmeansCosts[k],kmeansCosts[k-1]);
-                    --k;
-                }
-                ++cnt;
+                evaluate_kmeans(cost);
+                costs.push_back(cost);
             }
         }
 
-//         logger().info("KMEANS, Step 2: simplex-downhill optimization\n");
-//
-//         const int n = 2;
-//         // choose initial simplex points as the best parameters so far
-//         int kmeansNMPoints[n*(n+1)];
-//         float kmeansVals[n+1];
-//         for (int i=0;i<n+1;++i) {
-//             kmeansNMPoints[i*n] = (int)kmeansCosts[i].params["branching"];
-//             kmeansNMPoints[i*n+1] = (int)kmeansCosts[i].params["max-iterations"];
-//             kmeansVals[i] = kmeansCosts[i].timeCost;
-//         }
-//         KMeansSimpleDownhillFunctor kmeans_cost_func(*this);
-//         // run optimization
-//         optimizeSimplexDownhill(kmeansNMPoints,n,kmeans_cost_func,kmeansVals);
-//         // store results
-//         for (int i=0;i<n+1;++i) {
-//             kmeansCosts[i].params["branching"] = kmeansNMPoints[i*2];
-//             kmeansCosts[i].params["max-iterations"] = kmeansNMPoints[i*2+1];
-//             kmeansCosts[i].timeCost = kmeansVals[i];
-//         }
-
-        float optTimeCost = kmeansCosts[0].first.timeCost;
-        // recompute total costs factoring in the memory costs
-        for (int i=0;i<kmeansParamSpaceSize;++i) {
-            kmeansCosts[i].first.totalCost = (kmeansCosts[i].first.timeCost/optTimeCost + index_params.memory_weight * kmeansCosts[i].first.memoryCost);
-
-            int k = i;
-            while (k>0 && kmeansCosts[k].first.totalCost < kmeansCosts[k-1].first.totalCost) {
-                swap(kmeansCosts[k],kmeansCosts[k-1]);
-                k--;
-            }
-        }
-        // display the costs obtained
-        for (int i=0;i<kmeansParamSpaceSize;++i) {
-            logger().info("KMeans, branching=%d, iterations=%d, time_cost=%g[%g] (build=%g, search=%g), memory_cost=%g, cost=%g\n",
-                kmeansCosts[i].second.branching, kmeansCosts[i].second.iterations,
-            kmeansCosts[i].first.timeCost,kmeansCosts[i].first.timeCost/optTimeCost,
-            kmeansCosts[i].first.buildTimeCost, kmeansCosts[i].first.searchTimeCost,
-            kmeansCosts[i].first.memoryCost,kmeansCosts[i].first.totalCost);
-        }
-
-        return kmeansCosts[0];
+        //         Logger::info("KMEANS, Step 2: simplex-downhill optimization\n");
+        //
+        //         const int n = 2;
+        //         // choose initial simplex points as the best parameters so far
+        //         int kmeansNMPoints[n*(n+1)];
+        //         float kmeansVals[n+1];
+        //         for (int i=0;i<n+1;++i) {
+        //             kmeansNMPoints[i*n] = (int)kmeansCosts[i].params["branching"];
+        //             kmeansNMPoints[i*n+1] = (int)kmeansCosts[i].params["max-iterations"];
+        //             kmeansVals[i] = kmeansCosts[i].timeCost;
+        //         }
+        //         KMeansSimpleDownhillFunctor kmeans_cost_func(*this);
+        //         // run optimization
+        //         optimizeSimplexDownhill(kmeansNMPoints,n,kmeans_cost_func,kmeansVals);
+        //         // store results
+        //         for (int i=0;i<n+1;++i) {
+        //             kmeansCosts[i].params["branching"] = kmeansNMPoints[i*2];
+        //             kmeansCosts[i].params["max-iterations"] = kmeansNMPoints[i*2+1];
+        //             kmeansCosts[i].timeCost = kmeansVals[i];
+        //         }
     }
 
 
-    KDTreeCostData optimizeKDTree()
+    void optimizeKDTree(std::vector<CostData>& costs)
     {
-
-        logger().info("KD-TREE, Step 1: Exploring parameter space\n");
+        Logger::info("KD-TREE, Step 1: Exploring parameter space\n");
 
         // explore kd-tree parameters space using the parameters below
         int testTrees[] = { 1, 4, 8, 16, 32 };
 
-        size_t kdtreeParamSpaceSize = ARRAY_LEN(testTrees);
-        std::vector<KDTreeCostData> kdtreeCosts(kdtreeParamSpaceSize);
-
         // evaluate kdtree for all parameter combinations
-        int cnt = 0;
-        for (size_t i=0; i<ARRAY_LEN(testTrees); ++i) {
-        	kdtreeCosts[cnt].second.trees = testTrees[i];
+        for (size_t i = 0; i < FLANN_ARRAY_LEN(testTrees); ++i) {
+            CostData cost;
+            cost.params["trees"] = testTrees[i];
 
-            evaluate_kdtree(kdtreeCosts[cnt].first, kdtreeCosts[cnt].second);
-
-            int k = cnt;
-            // order by time cost
-            while (k>0 && kdtreeCosts[k].first.timeCost < kdtreeCosts[k-1].first.timeCost) {
-                swap(kdtreeCosts[k],kdtreeCosts[k-1]);
-                --k;
-            }
-            ++cnt;
+            evaluate_kdtree(cost);
+            costs.push_back(cost);
         }
 
-//         logger().info("KD-TREE, Step 2: simplex-downhill optimization\n");
-//
-//         const int n = 1;
-//         // choose initial simplex points as the best parameters so far
-//         int kdtreeNMPoints[n*(n+1)];
-//         float kdtreeVals[n+1];
-//         for (int i=0;i<n+1;++i) {
-//             kdtreeNMPoints[i] = (int)kdtreeCosts[i].params["trees"];
-//             kdtreeVals[i] = kdtreeCosts[i].timeCost;
-//         }
-//         KDTreeSimpleDownhillFunctor kdtree_cost_func(*this);
-//         // run optimization
-//         optimizeSimplexDownhill(kdtreeNMPoints,n,kdtree_cost_func,kdtreeVals);
-//         // store results
-//         for (int i=0;i<n+1;++i) {
-//             kdtreeCosts[i].params["trees"] = kdtreeNMPoints[i];
-//             kdtreeCosts[i].timeCost = kdtreeVals[i];
-//         }
-
-        float optTimeCost = kdtreeCosts[0].first.timeCost;
-        // recompute costs for kd-tree factoring in memory cost
-        for (size_t i=0;i<kdtreeParamSpaceSize;++i) {
-            kdtreeCosts[i].first.totalCost = (kdtreeCosts[i].first.timeCost/optTimeCost + index_params.memory_weight * kdtreeCosts[i].first.memoryCost);
-
-            int k = (int)i;
-            while (k>0 && kdtreeCosts[k].first.totalCost < kdtreeCosts[k-1].first.totalCost) {
-                swap(kdtreeCosts[k],kdtreeCosts[k-1]);
-                k--;
-            }
-        }
-        // display costs obtained
-        for (size_t i=0;i<kdtreeParamSpaceSize;++i) {
-            logger().info("kd-tree, trees=%d, time_cost=%g[%g] (build=%g, search=%g), memory_cost=%g, cost=%g\n",
-            kdtreeCosts[i].second.trees,kdtreeCosts[i].first.timeCost,kdtreeCosts[i].first.timeCost/optTimeCost,
-            kdtreeCosts[i].first.buildTimeCost, kdtreeCosts[i].first.searchTimeCost,
-            kdtreeCosts[i].first.memoryCost,kdtreeCosts[i].first.totalCost);
-        }
-
-        return kdtreeCosts[0];
+        //         Logger::info("KD-TREE, Step 2: simplex-downhill optimization\n");
+        //
+        //         const int n = 1;
+        //         // choose initial simplex points as the best parameters so far
+        //         int kdtreeNMPoints[n*(n+1)];
+        //         float kdtreeVals[n+1];
+        //         for (int i=0;i<n+1;++i) {
+        //             kdtreeNMPoints[i] = (int)kdtreeCosts[i].params["trees"];
+        //             kdtreeVals[i] = kdtreeCosts[i].timeCost;
+        //         }
+        //         KDTreeSimpleDownhillFunctor kdtree_cost_func(*this);
+        //         // run optimization
+        //         optimizeSimplexDownhill(kdtreeNMPoints,n,kdtree_cost_func,kdtreeVals);
+        //         // store results
+        //         for (int i=0;i<n+1;++i) {
+        //             kdtreeCosts[i].params["trees"] = kdtreeNMPoints[i];
+        //             kdtreeCosts[i].timeCost = kdtreeVals[i];
+        //         }
     }
 
     /**
-        Chooses the best nearest-neighbor algorithm and estimates the optimal
-        parameters to use when building the index (for a given precision).
-        Returns a dictionary with the optimal parameters.
-    */
-    IndexParams* estimateBuildParams()
+     *  Chooses the best nearest-neighbor algorithm and estimates the optimal
+     *  parameters to use when building the index (for a given precision).
+     *  Returns a dictionary with the optimal parameters.
+     */
+    IndexParams estimateBuildParams()
     {
-        int sampleSize = int(index_params.sample_fraction*dataset.rows);
-        int testSampleSize = std::min(sampleSize/10, 1000);
+        std::vector<CostData> costs;
 
-        logger().info("Entering autotuning, dataset size: %d, sampleSize: %d, testSampleSize: %d\n",dataset.rows, sampleSize, testSampleSize);
+        int sampleSize = int(sample_fraction_ * dataset_.rows);
+        int testSampleSize = std::min(sampleSize / 10, 1000);
+
+        Logger::info("Entering autotuning, dataset size: %d, sampleSize: %d, testSampleSize: %d, target precision: %g\n", dataset_.rows, sampleSize, testSampleSize, target_precision_);
 
         // For a very small dataset, it makes no sense to build any fancy index, just
         // use linear search
-        if (testSampleSize<10) {
-            logger().info("Choosing linear, dataset too small\n");
-            return new LinearIndexParams();
+        if (testSampleSize < 10) {
+            Logger::info("Choosing linear, dataset too small\n");
+            return LinearIndexParams();
         }
 
         // We use a fraction of the original dataset to speedup the autotune algorithm
-        sampledDataset = random_sample(dataset,sampleSize);
+        sampledDataset_ = random_sample(dataset_, sampleSize);
         // We use a cross-validation approach, first we sample a testset from the dataset
-        testDataset = random_sample(sampledDataset,testSampleSize,true);
+        testDataset_ = random_sample(sampledDataset_, testSampleSize, true);
 
         // We compute the ground truth using linear search
-        logger().info("Computing ground truth... \n");
-        gt_matches = Matrix<int>(new int[testDataset.rows],(long)testDataset.rows, 1);
+        Logger::info("Computing ground truth... \n");
+        gt_matches_ = Matrix<int>(new int[testDataset_.rows], testDataset_.rows, 1);
         StartStopTimer t;
         t.start();
-        compute_ground_truth(sampledDataset, testDataset, gt_matches, 0);
+        compute_ground_truth<Distance>(sampledDataset_, testDataset_, gt_matches_, 0, distance_);
         t.stop();
-        float bestCost = (float)t.value;
-        IndexParams* bestParams = new LinearIndexParams();
+
+        CostData linear_cost;
+        linear_cost.searchTimeCost = (float)t.value;
+        linear_cost.buildTimeCost = 0;
+        linear_cost.memoryCost = 0;
+        linear_cost.params["algorithm"] = FLANN_INDEX_LINEAR;
+
+        costs.push_back(linear_cost);
 
         // Start parameter autotune process
-        logger().info("Autotuning parameters...\n");
+        Logger::info("Autotuning parameters...\n");
 
+        optimizeKMeans(costs);
+        optimizeKDTree(costs);
 
-        KMeansCostData kmeansCost = optimizeKMeans();
-        if (kmeansCost.first.totalCost<bestCost) {
-            bestParams = new KMeansIndexParams(kmeansCost.second);
-            bestCost = kmeansCost.first.totalCost;
+        float bestTimeCost = costs[0].searchTimeCost;
+        for (size_t i = 0; i < costs.size(); ++i) {
+            float timeCost = costs[i].buildTimeCost * build_weight_ + costs[i].searchTimeCost;
+            if (timeCost < bestTimeCost) {
+                bestTimeCost = timeCost;
+            }
         }
 
-        KDTreeCostData kdtreeCost = optimizeKDTree();
-
-        if (kdtreeCost.first.totalCost<bestCost) {
-            bestParams = new KDTreeIndexParams(kdtreeCost.second);
-            bestCost = kdtreeCost.first.totalCost;
+        float bestCost = costs[0].searchTimeCost / bestTimeCost;
+        IndexParams bestParams = costs[0].params;
+        if (bestTimeCost > 0) {
+            for (size_t i = 0; i < costs.size(); ++i) {
+                float crtCost = (costs[i].buildTimeCost * build_weight_ + costs[i].searchTimeCost) / bestTimeCost +
+                                memory_weight_ * costs[i].memoryCost;
+                if (crtCost < bestCost) {
+                    bestCost = crtCost;
+                    bestParams = costs[i].params;
+                }
+            }
         }
 
-        gt_matches.release();
-        sampledDataset.release();
-        testDataset.release();
+        delete[] gt_matches_.data;
+        delete[] testDataset_.data;
+        delete[] sampledDataset_.data;
 
         return bestParams;
     }
@@ -538,48 +478,48 @@ private:
 
 
     /**
-        Estimates the search time parameters needed to get the desired precision.
-        Precondition: the index is built
-        Postcondition: the searchParams will have the optimum params set, also the speedup obtained over linear search.
-    */
+     *  Estimates the search time parameters needed to get the desired precision.
+     *  Precondition: the index is built
+     *  Postcondition: the searchParams will have the optimum params set, also the speedup obtained over linear search.
+     */
     float estimateSearchParams(SearchParams& searchParams)
     {
         const int nn = 1;
         const size_t SAMPLE_COUNT = 1000;
 
-        assert(bestIndex!=NULL);   // must have a valid index
+        assert(bestIndex_ != NULL); // must have a valid index
 
         float speedup = 0;
 
-        int samples = (int)std::min(dataset.rows/10, SAMPLE_COUNT);
-        if (samples>0) {
-            Matrix<ELEM_TYPE> testDataset = random_sample(dataset,samples);
+        int samples = (int)std::min(dataset_.rows / 10, SAMPLE_COUNT);
+        if (samples > 0) {
+            Matrix<ElementType> testDataset = random_sample(dataset_, samples);
 
-            logger().info("Computing ground truth\n");
+            Logger::info("Computing ground truth\n");
 
             // we need to compute the ground truth first
-            Matrix<int> gt_matches(new int[testDataset.rows],(long)testDataset.rows,1);
+            Matrix<int> gt_matches(new int[testDataset.rows], testDataset.rows, 1);
             StartStopTimer t;
             t.start();
-            compute_ground_truth(dataset, testDataset, gt_matches,1);
+            compute_ground_truth<Distance>(dataset_, testDataset, gt_matches, 1, distance_);
             t.stop();
             float linear = (float)t.value;
 
             int checks;
-            logger().info("Estimating number of checks\n");
+            Logger::info("Estimating number of checks\n");
 
             float searchTime;
             float cb_index;
-            if (bestIndex->getType() == FLANN_INDEX_KMEANS) {
-                logger().info("KMeans algorithm, estimating cluster border factor\n");
-                KMeansIndex<ELEM_TYPE>* kmeans = (KMeansIndex<ELEM_TYPE>*)bestIndex;
+            if (bestIndex_->getType() == FLANN_INDEX_KMEANS) {
+                Logger::info("KMeans algorithm, estimating cluster border factor\n");
+                KMeansIndex<Distance>* kmeans = (KMeansIndex<Distance>*)bestIndex_;
                 float bestSearchTime = -1;
                 float best_cb_index = -1;
                 int best_checks = -1;
-                for (cb_index = 0;cb_index<1.1f; cb_index+=0.2f) {
+                for (cb_index = 0; cb_index < 1.1f; cb_index += 0.2f) {
                     kmeans->set_cb_index(cb_index);
-                    searchTime = test_index_precision(*kmeans, dataset, testDataset, gt_matches, index_params.target_precision, checks, nn, 1);
-                    if (searchTime<bestSearchTime || bestSearchTime == -1) {
+                    searchTime = test_index_precision(*kmeans, dataset_, testDataset, gt_matches, target_precision_, checks, distance_, nn, 1);
+                    if ((searchTime < bestSearchTime) || (bestSearchTime == -1)) {
                         bestSearchTime = searchTime;
                         best_cb_index = cb_index;
                         best_checks = checks;
@@ -590,26 +530,54 @@ private:
                 checks = best_checks;
 
                 kmeans->set_cb_index(best_cb_index);
-                logger().info("Optimum cb_index: %g\n",cb_index);
-                ((KMeansIndexParams*)bestParams)->cb_index = cb_index;
+                Logger::info("Optimum cb_index: %g\n", cb_index);
+                bestParams_["cb_index"] = cb_index;
             }
             else {
-                searchTime = test_index_precision(*bestIndex, dataset, testDataset, gt_matches, index_params.target_precision, checks, nn, 1);
+                searchTime = test_index_precision(*bestIndex_, dataset_, testDataset, gt_matches, target_precision_, checks, distance_, nn, 1);
             }
 
-            logger().info("Required number of checks: %d \n",checks);;
-            searchParams.checks = checks;
+            Logger::info("Required number of checks: %d \n", checks);
+            searchParams["checks"] = checks;
 
-            speedup = linear/searchTime;
+            speedup = linear / searchTime;
 
-            gt_matches.release();
+            delete[] gt_matches.data;
+            delete[] testDataset.data;
         }
 
         return speedup;
     }
 
+private:
+    NNIndex<Distance>* bestIndex_;
+
+    IndexParams bestParams_;
+    SearchParams bestSearchParams_;
+
+    Matrix<ElementType> sampledDataset_;
+    Matrix<ElementType> testDataset_;
+    Matrix<int> gt_matches_;
+
+    float speedup_;
+
+    /**
+     * The dataset used by this index
+     */
+    const Matrix<ElementType> dataset_;
+
+    /**
+     * Index parameters
+     */
+    float target_precision_;
+    float build_weight_;
+    float memory_weight_;
+    float sample_fraction_;
+
+    Distance distance_;
+
+
 };
+}
 
-} // namespace cvflann
-
-#endif /* _OPENCV_AUTOTUNEDINDEX_H_ */
+#endif /* OPENCV_FLANN_AUTOTUNED_INDEX_H_ */
diff --git a/modules/flann/include/opencv2/flann/composite_index.h b/modules/flann/include/opencv2/flann/composite_index.h
index 7738bf6a35..527ca1ad77 100644
--- a/modules/flann/include/opencv2/flann/composite_index.h
+++ b/modules/flann/include/opencv2/flann/composite_index.h
@@ -28,135 +28,167 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_COMPOSITETREE_H_
-#define _OPENCV_COMPOSITETREE_H_
+#ifndef OPENCV_FLANN_COMPOSITE_INDEX_H_
+#define OPENCV_FLANN_COMPOSITE_INDEX_H_
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
+#include "general.h"
+#include "nn_index.h"
+#include "kdtree_index.h"
+#include "kmeans_index.h"
 
 namespace cvflann
 {
 
-
-struct CompositeIndexParams : public IndexParams {
-	CompositeIndexParams(int trees_ = 4, int branching_ = 32, int iterations_ = 11,
-			flann_centers_init_t centers_init_ = FLANN_CENTERS_RANDOM, float cb_index_ = 0.2 ) :
-		IndexParams(FLANN_INDEX_COMPOSITE),
-		trees(trees_),
-		branching(branching_),
-		iterations(iterations_),
-		centers_init(centers_init_),
-		cb_index(cb_index_) {};
-
-	int trees;                 // number of randomized trees to use (for kdtree)
-	int branching;             // branching factor (for kmeans tree)
-	int iterations;            // max iterations to perform in one kmeans clustering (kmeans tree)
-	flann_centers_init_t centers_init;          // algorithm used for picking the initial cluster centers for kmeans tree
-    float cb_index;            // cluster boundary index. Used when searching the kmeans tree
-
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-		logger().info("Trees: %d\n", trees);
-		logger().info("Branching: %d\n", branching);
-		logger().info("Iterations: %d\n", iterations);
-		logger().info("Centres initialisation: %d\n", centers_init);
-		logger().info("Cluster boundary weight: %g\n", cb_index);
-	}
+/**
+ * Index parameters for the CompositeIndex.
+ */
+struct CompositeIndexParams : public IndexParams
+{
+    CompositeIndexParams(int trees = 4, int branching = 32, int iterations = 11,
+                         flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, float cb_index = 0.2 )
+    {
+        (*this)["algorithm"] = FLANN_INDEX_KMEANS;
+        // number of randomized trees to use (for kdtree)
+        (*this)["trees"] = trees;
+        // branching factor
+        (*this)["branching"] = branching;
+        // max iterations to perform in one kmeans clustering (kmeans tree)
+        (*this)["iterations"] = iterations;
+        // algorithm used for picking the initial cluster centers for kmeans tree
+        (*this)["centers_init"] = centers_init;
+        // cluster boundary index. Used when searching the kmeans tree
+        (*this)["cb_index"] = cb_index;
+    }
 };
 
 
-
-template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
-class CompositeIndex : public NNIndex<ELEM_TYPE>
+/**
+ * This index builds a kd-tree index and a k-means index and performs nearest
+ * neighbour search both indexes. This gives a slight boost in search performance
+ * as some of the neighbours that are missed by one index are found by the other.
+ */
+template <typename Distance>
+class CompositeIndex : public NNIndex<Distance>
 {
-	KMeansIndex<ELEM_TYPE, DIST_TYPE>* kmeans;
-	KDTreeIndex<ELEM_TYPE, DIST_TYPE>* kdtree;
-
-    const Matrix<ELEM_TYPE> dataset;
-
-    const IndexParams& index_params;
-
-	CompositeIndex& operator=(const CompositeIndex&);
-	CompositeIndex(const CompositeIndex&);
 public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
 
-	CompositeIndex(const Matrix<ELEM_TYPE>& inputData, const CompositeIndexParams& params = CompositeIndexParams() ) :
-		dataset(inputData), index_params(params)
-	{
-		KDTreeIndexParams kdtree_params(params.trees);
-		KMeansIndexParams kmeans_params(params.branching, params.iterations, params.centers_init, params.cb_index);
+    /**
+     * Index constructor
+     * @param inputData dataset containing the points to index
+     * @param params Index parameters
+     * @param d Distance functor
+     * @return
+     */
+    CompositeIndex(const Matrix<ElementType>& inputData, const IndexParams& params = CompositeIndexParams(),
+                   Distance d = Distance()) : index_params_(params)
+    {
+        kdtree_index_ = new KDTreeIndex<Distance>(inputData, params, d);
+        kmeans_index_ = new KMeansIndex<Distance>(inputData, params, d);
 
-		kdtree = new KDTreeIndex<ELEM_TYPE, DIST_TYPE>(inputData,kdtree_params);
-		kmeans = new KMeansIndex<ELEM_TYPE, DIST_TYPE>(inputData,kmeans_params);
+    }
 
-	}
-
-	virtual ~CompositeIndex()
-	{
-		delete kdtree;
-		delete kmeans;
-	}
+    CompositeIndex(const CompositeIndex&);
+    CompositeIndex& operator=(const CompositeIndex&);
 
+    virtual ~CompositeIndex()
+    {
+        delete kdtree_index_;
+        delete kmeans_index_;
+    }
 
+    /**
+     * @return The index type
+     */
     flann_algorithm_t getType() const
     {
         return FLANN_INDEX_COMPOSITE;
     }
 
-
+    /**
+     * @return Size of the index
+     */
     size_t size() const
-	{
-		return dataset.rows;
-	}
+    {
+        return kdtree_index_->size();
+    }
 
-	size_t veclen() const
-	{
-		return dataset.cols;
-	}
+    /**
+     * \returns The dimensionality of the features in this index.
+     */
+    size_t veclen() const
+    {
+        return kdtree_index_->veclen();
+    }
 
+    /**
+     * \returns The amount of memory (in bytes) used by the index.
+     */
+    int usedMemory() const
+    {
+        return kmeans_index_->usedMemory() + kdtree_index_->usedMemory();
+    }
 
-	int usedMemory() const
-	{
-		return kmeans->usedMemory()+kdtree->usedMemory();
-	}
-
-	void buildIndex()
-	{
-		logger().info("Building kmeans tree...\n");
-		kmeans->buildIndex();
-		logger().info("Building kdtree tree...\n");
-		kdtree->buildIndex();
-	}
-
+    /**
+     * \brief Builds the index
+     */
+    void buildIndex()
+    {
+        Logger::info("Building kmeans tree...\n");
+        kmeans_index_->buildIndex();
+        Logger::info("Building kdtree tree...\n");
+        kdtree_index_->buildIndex();
+    }
 
+    /**
+     * \brief Saves the index to a stream
+     * \param stream The stream to save the index to
+     */
     void saveIndex(FILE* stream)
     {
-    	kmeans->saveIndex(stream);
-    	kdtree->saveIndex(stream);
+        kmeans_index_->saveIndex(stream);
+        kdtree_index_->saveIndex(stream);
     }
 
-
+    /**
+     * \brief Loads the index from a stream
+     * \param stream The stream from which the index is loaded
+     */
     void loadIndex(FILE* stream)
     {
-    	kmeans->loadIndex(stream);
-    	kdtree->loadIndex(stream);
+        kmeans_index_->loadIndex(stream);
+        kdtree_index_->loadIndex(stream);
     }
 
-	void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams)
-	{
-		kmeans->findNeighbors(result,vec,searchParams);
-		kdtree->findNeighbors(result,vec,searchParams);
-	}
+    /**
+     * \returns The index parameters
+     */
+    IndexParams getParameters() const
+    {
+        return index_params_;
+    }
 
-	const IndexParams* getParameters() const
-	{
-		return &index_params;
-	}
+    /**
+     * \brief Method that searches for nearest-neighbours
+     */
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+    {
+        kmeans_index_->findNeighbors(result, vec, searchParams);
+        kdtree_index_->findNeighbors(result, vec, searchParams);
+    }
 
+private:
+    /** The k-means index */
+    KMeansIndex<Distance>* kmeans_index_;
 
+    /** The kd-tree index */
+    KDTreeIndex<Distance>* kdtree_index_;
+
+    /** The index parameters */
+    const IndexParams index_params_;
 };
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_COMPOSITETREE_H_
+#endif //OPENCV_FLANN_COMPOSITE_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/config.h b/modules/flann/include/opencv2/flann/config.h
new file mode 100644
index 0000000000..56832fd37f
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/config.h
@@ -0,0 +1,38 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+
+#ifndef OPENCV_FLANN_CONFIG_H_
+#define OPENCV_FLANN_CONFIG_H_
+
+#ifdef FLANN_VERSION_
+#undef FLANN_VERSION_
+#endif
+#define FLANN_VERSION_ "1.6.10"
+
+#endif /* OPENCV_FLANN_CONFIG_H_ */
diff --git a/modules/flann/include/opencv2/flann/defines.h b/modules/flann/include/opencv2/flann/defines.h
new file mode 100644
index 0000000000..c71e149ec8
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/defines.h
@@ -0,0 +1,175 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+
+#ifndef OPENCV_FLANN_DEFINES_H_
+#define OPENCV_FLANN_DEFINES_H_
+
+#include "config.h"
+
+#ifdef FLANN_EXPORT
+#undef FLANN_EXPORT
+#endif
+#ifdef WIN32
+/* win32 dll export/import directives */
+ #ifdef FLANN_EXPORTS
+  #define FLANN_EXPORT __declspec(dllexport)
+ #elif defined(FLANN_STATIC)
+  #define FLANN_EXPORT
+ #else
+  #define FLANN_EXPORT __declspec(dllimport)
+ #endif
+#else
+/* unix needs nothing */
+ #define FLANN_EXPORT
+#endif
+
+
+#ifdef FLANN_DEPRECATED
+#undef FLANN_DEPRECATED
+#endif
+#ifdef __GNUC__
+#define FLANN_DEPRECATED __attribute__ ((deprecated))
+#elif defined(_MSC_VER)
+#define FLANN_DEPRECATED __declspec(deprecated)
+#else
+#pragma message("WARNING: You need to implement FLANN_DEPRECATED for this compiler")
+#define FLANN_DEPRECATED
+#endif
+
+
+#undef FLANN_PLATFORM_32_BIT
+#undef FLANN_PLATFORM_64_BIT
+#if __amd64__ || __x86_64__ || _WIN64 || _M_X64
+#define FLANN_PLATFORM_64_BIT
+#else
+#define FLANN_PLATFORM_32_BIT
+#endif
+
+
+#undef FLANN_ARRAY_LEN
+#define FLANN_ARRAY_LEN(a) (sizeof(a)/sizeof(a[0]))
+
+namespace cvflann {
+
+/* Nearest neighbour index algorithms */
+enum flann_algorithm_t
+{
+    FLANN_INDEX_LINEAR = 0,
+    FLANN_INDEX_KDTREE = 1,
+    FLANN_INDEX_KMEANS = 2,
+    FLANN_INDEX_COMPOSITE = 3,
+    FLANN_INDEX_KDTREE_SINGLE = 4,
+    FLANN_INDEX_HIERARCHICAL = 5,
+    FLANN_INDEX_LSH = 6,
+    FLANN_INDEX_SAVED = 254,
+    FLANN_INDEX_AUTOTUNED = 255,
+
+    // deprecated constants, should use the FLANN_INDEX_* ones instead
+    LINEAR = 0,
+    KDTREE = 1,
+    KMEANS = 2,
+    COMPOSITE = 3,
+    KDTREE_SINGLE = 4,
+    SAVED = 254,
+    AUTOTUNED = 255
+};
+
+
+
+enum flann_centers_init_t
+{
+    FLANN_CENTERS_RANDOM = 0,
+    FLANN_CENTERS_GONZALES = 1,
+    FLANN_CENTERS_KMEANSPP = 2,
+
+    // deprecated constants, should use the FLANN_CENTERS_* ones instead
+    CENTERS_RANDOM = 0,
+    CENTERS_GONZALES = 1,
+    CENTERS_KMEANSPP = 2
+};
+
+enum flann_log_level_t
+{
+    FLANN_LOG_NONE = 0,
+    FLANN_LOG_FATAL = 1,
+    FLANN_LOG_ERROR = 2,
+    FLANN_LOG_WARN = 3,
+    FLANN_LOG_INFO = 4,
+};
+
+enum flann_distance_t
+{
+    FLANN_DIST_EUCLIDEAN = 1,
+    FLANN_DIST_L2 = 1,
+    FLANN_DIST_MANHATTAN = 2,
+    FLANN_DIST_L1 = 2,
+    FLANN_DIST_MINKOWSKI = 3,
+    FLANN_DIST_MAX   = 4,
+    FLANN_DIST_HIST_INTERSECT   = 5,
+    FLANN_DIST_HELLINGER = 6,
+    FLANN_DIST_CHI_SQUARE = 7,
+    FLANN_DIST_CS         = 7,
+    FLANN_DIST_KULLBACK_LEIBLER  = 8,
+    FLANN_DIST_KL                = 8,
+
+    // deprecated constants, should use the FLANN_DIST_* ones instead
+    EUCLIDEAN = 1,
+    MANHATTAN = 2,
+    MINKOWSKI = 3,
+    MAX_DIST   = 4,
+    HIST_INTERSECT   = 5,
+    HELLINGER = 6,
+    CS         = 7,
+    KL         = 8,
+    KULLBACK_LEIBLER  = 8
+};
+
+enum flann_datatype_t
+{
+    FLANN_INT8 = 0,
+    FLANN_INT16 = 1,
+    FLANN_INT32 = 2,
+    FLANN_INT64 = 3,
+    FLANN_UINT8 = 4,
+    FLANN_UINT16 = 5,
+    FLANN_UINT32 = 6,
+    FLANN_UINT64 = 7,
+    FLANN_FLOAT32 = 8,
+    FLANN_FLOAT64 = 9
+};
+
+enum
+{
+    FLANN_CHECKS_UNLIMITED = -1,
+    FLANN_CHECKS_AUTOTUNED = -2
+};
+
+}
+
+#endif /* OPENCV_FLANN_DEFINES_H_ */
diff --git a/modules/flann/include/opencv2/flann/dist.h b/modules/flann/include/opencv2/flann/dist.h
index 2ddbee31e8..094fd3435c 100644
--- a/modules/flann/include/opencv2/flann/dist.h
+++ b/modules/flann/include/opencv2/flann/dist.h
@@ -28,302 +28,777 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_DIST_H_
-#define _OPENCV_DIST_H_
+#ifndef OPENCV_FLANN_DIST_H_
+#define OPENCV_FLANN_DIST_H_
 
 #include <cmath>
+#include <cstdlib>
+#include <string.h>
+#ifdef _MSC_VER
+typedef unsigned uint32_t;
+typedef unsigned __int64 uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+#include "defines.h"
 
-#include "opencv2/flann/general.h"
 
 namespace cvflann
 {
 
-/**
- * Distance function by default set to the custom distance
- * function. This can be set to a specific distance function
- * for further efficiency.
- */
-#define flann_dist custom_dist
-//#define flann_dist euclidean_dist
+template<typename T>
+inline T abs(T x) { return (x<0) ? -x : x; }
+
+template<>
+inline int abs<int>(int x) { return ::abs(x); }
+
+template<>
+inline float abs<float>(float x) { return fabsf(x); }
+
+template<>
+inline double abs<double>(double x) { return fabs(x); }
+
+template<>
+inline long double abs<long double>(long double x) { return fabsl(x); }
+
+
+template<typename T>
+struct Accumulator { typedef T Type; };
+template<>
+struct Accumulator<unsigned char>  { typedef float Type; };
+template<>
+struct Accumulator<unsigned short> { typedef float Type; };
+template<>
+struct Accumulator<unsigned int> { typedef float Type; };
+template<>
+struct Accumulator<char>   { typedef float Type; };
+template<>
+struct Accumulator<short>  { typedef float Type; };
+template<>
+struct Accumulator<int> { typedef float Type; };
+
+
+class True
+{
+};
+
+class False
+{
+};
 
 
 /**
- *  Compute the squared Euclidean distance between two vectors.
+ * Squared Euclidean distance functor.
  *
- *	This is highly optimised, with loop unrolling, as it is one
- *	of the most expensive inner loops.
- *
- *	The computation of squared root at the end is omitted for
- *	efficiency.
+ * This is the simpler, unrolled version. This is preferable for
+ * very low dimensionality data (eg 3D points)
  */
-template <typename Iterator1, typename Iterator2>
-double euclidean_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
+template<class T>
+struct L2_Simple
 {
-	double distsq = acc;
-	double diff0, diff1, diff2, diff3;
-	Iterator1 lastgroup = last1 - 3;
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
 
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		diff0 = first1[0] - first2[0];
-		diff1 = first1[1] - first2[1];
-		diff2 = first1[2] - first2[2];
-		diff3 = first1[3] - first2[3];
-		distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		diff0 = *first1++ - *first2++;
-		distsq += diff0 * diff0;
-	}
-	return distsq;
-}
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff;
+        for(size_t i = 0; i < size; ++i ) {
+            diff = *a++ - *b++;
+            result += diff*diff;
+        }
+        return result;
+    }
+
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        return (a-b)*(a-b);
+    }
+};
 
-CV_EXPORTS double euclidean_dist(const unsigned char* first1, const unsigned char* last1, unsigned char* first2, double acc);
 
 
 /**
- *  Compute the Manhattan (L_1) distance between two vectors.
- *
- *	This is highly optimised, with loop unrolling, as it is one
- *	of the most expensive inner loops.
+ * Squared Euclidean distance functor, optimized version
  */
-template <typename Iterator1, typename Iterator2>
-double manhattan_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
+template<class T>
+struct L2
 {
-	double distsq = acc;
-	double diff0, diff1, diff2, diff3;
-	Iterator1 lastgroup = last1 - 3;
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
 
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		diff0 = fabs(first1[0] - first2[0]);
-		diff1 = fabs(first1[1] - first2[1]);
-		diff2 = fabs(first1[2] - first2[2]);
-		diff3 = fabs(first1[3] - first2[3]);
-		distsq += diff0 + diff1 + diff2  + diff3;
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		diff0 = fabs(*first1++ - *first2++);
-		distsq += diff0;
-	}
-	return distsq;
-}
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the squared Euclidean distance between two vectors.
+     *
+     *	This is highly optimised, with loop unrolling, as it is one
+     *	of the most expensive inner loops.
+     *
+     *	The computation of squared root at the end is omitted for
+     *	efficiency.
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff0, diff1, diff2, diff3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            diff0 = (ResultType)(a[0] - b[0]);
+            diff1 = (ResultType)(a[1] - b[1]);
+            diff2 = (ResultType)(a[2] - b[2]);
+            diff3 = (ResultType)(a[3] - b[3]);
+            result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
+            a += 4;
+            b += 4;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+        while (a < last) {
+            diff0 = (ResultType)(*a++ - *b++);
+            result += diff0 * diff0;
+        }
+        return result;
+    }
+
+    /**
+     *	Partial euclidean distance, using just one dimension. This is used by the
+     *	kd-tree when computing partial distances while traversing the tree.
+     *
+     *	Squared root is omitted for efficiency.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        return (a-b)*(a-b);
+    }
+};
 
 
-CV_EXPORTS int flann_minkowski_order();
+/*
+ * Manhattan distance functor, optimized version
+ */
+template<class T>
+struct L1
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the Manhattan (L_1) distance between two vectors.
+     *
+     *	This is highly optimised, with loop unrolling, as it is one
+     *	of the most expensive inner loops.
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff0, diff1, diff2, diff3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            diff0 = (ResultType)abs(a[0] - b[0]);
+            diff1 = (ResultType)abs(a[1] - b[1]);
+            diff2 = (ResultType)abs(a[2] - b[2]);
+            diff3 = (ResultType)abs(a[3] - b[3]);
+            result += diff0 + diff1 + diff2 + diff3;
+            a += 4;
+            b += 4;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+        while (a < last) {
+            diff0 = (ResultType)abs(*a++ - *b++);
+            result += diff0;
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        return abs(a-b);
+    }
+};
+
+
+
+template<class T>
+struct MinkowskiDistance
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    int order;
+
+    MinkowskiDistance(int order_) : order(order_) {}
+
+    /**
+     *  Compute the Minkowsky (L_p) distance between two vectors.
+     *
+     *	This is highly optimised, with loop unrolling, as it is one
+     *	of the most expensive inner loops.
+     *
+     *	The computation of squared root at the end is omitted for
+     *	efficiency.
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff0, diff1, diff2, diff3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            diff0 = (ResultType)abs(a[0] - b[0]);
+            diff1 = (ResultType)abs(a[1] - b[1]);
+            diff2 = (ResultType)abs(a[2] - b[2]);
+            diff3 = (ResultType)abs(a[3] - b[3]);
+            result += pow(diff0,order) + pow(diff1,order) + pow(diff2,order) + pow(diff3,order);
+            a += 4;
+            b += 4;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+        while (a < last) {
+            diff0 = (ResultType)abs(*a++ - *b++);
+            result += pow(diff0,order);
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        return pow(static_cast<ResultType>(abs(a-b)),order);
+    }
+};
+
+
+
+template<class T>
+struct MaxDistance
+{
+    typedef False is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the max distance (L_infinity) between two vectors.
+     *
+     *  This distance is not a valid kdtree distance, it's not dimensionwise additive.
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff0, diff1, diff2, diff3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            diff0 = abs(a[0] - b[0]);
+            diff1 = abs(a[1] - b[1]);
+            diff2 = abs(a[2] - b[2]);
+            diff3 = abs(a[3] - b[3]);
+            if (diff0>result) {result = diff0; }
+            if (diff1>result) {result = diff1; }
+            if (diff2>result) {result = diff2; }
+            if (diff3>result) {result = diff3; }
+            a += 4;
+            b += 4;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+        while (a < last) {
+            diff0 = abs(*a++ - *b++);
+            result = (diff0>result) ? diff0 : result;
+        }
+        return result;
+    }
+
+    /* This distance functor is not dimension-wise additive, which
+     * makes it an invalid kd-tree distance, not implementing the accum_dist method */
+
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /**
- *  Compute the Minkowski (L_p) distance between two vectors.
- *
- *	This is highly optimised, with loop unrolling, as it is one
- *	of the most expensive inner loops.
- *
- *	The computation of squared root at the end is omitted for
- *	efficiency.
+ * Hamming distance functor - counts the bit differences between two strings - useful for the Brief descriptor
+ * bit count of A exclusive XOR'ed with B
  */
-template <typename Iterator1, typename Iterator2>
-double minkowski_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
+struct HammingLUT
 {
-	double distsq = acc;
-	double diff0, diff1, diff2, diff3;
-	Iterator1 lastgroup = last1 - 3;
+    typedef False is_kdtree_distance;
+    typedef False is_vector_space_distance;
 
-	int p = flann_minkowski_order();
+    typedef unsigned char ElementType;
+    typedef int ResultType;
 
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		diff0 = fabs(first1[0] - first2[0]);
-		diff1 = fabs(first1[1] - first2[1]);
-		diff2 = fabs(first1[2] - first2[2]);
-		diff3 = fabs(first1[3] - first2[3]);
-		distsq += pow(diff0,p) + pow(diff1,p) + pow(diff2,p)  + pow(diff3,p);
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		diff0 = fabs(*first1++ - *first2++);
-		distsq += pow(diff0,p);
-	}
-	return distsq;
-}
+    /** this will count the bits in a ^ b
+     */
+    ResultType operator()(const unsigned char* a, const unsigned char* b, int size) const
+    {
+        ResultType result = 0;
+        for (int i = 0; i < size; i++) {
+            result += byteBitsLookUp(a[i] ^ b[i]);
+        }
+        return result;
+    }
 
 
-// L_infinity distance (NOT A VALID KD-TREE DISTANCE - NOT DIMENSIONWISE ADDITIVE)
-template <typename Iterator1, typename Iterator2>
-double max_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
-{
-	double dist = acc;
-	Iterator1 lastgroup = last1 - 3;
-	double diff0, diff1, diff2, diff3;
+    /** \brief given a byte, count the bits using a look up table
+     *  \param b the byte to count bits.  The look up table has an entry for all
+     *  values of b, where that entry is the number of bits.
+     *  \return the number of bits in byte b
+     */
+    static unsigned char byteBitsLookUp(unsigned char b)
+    {
+        static const unsigned char table[256]  = {
+            /* 0 */ 0, /* 1 */ 1, /* 2 */ 1, /* 3 */ 2,
+            /* 4 */ 1, /* 5 */ 2, /* 6 */ 2, /* 7 */ 3,
+            /* 8 */ 1, /* 9 */ 2, /* a */ 2, /* b */ 3,
+            /* c */ 2, /* d */ 3, /* e */ 3, /* f */ 4,
+            /* 10 */ 1, /* 11 */ 2, /* 12 */ 2, /* 13 */ 3,
+            /* 14 */ 2, /* 15 */ 3, /* 16 */ 3, /* 17 */ 4,
+            /* 18 */ 2, /* 19 */ 3, /* 1a */ 3, /* 1b */ 4,
+            /* 1c */ 3, /* 1d */ 4, /* 1e */ 4, /* 1f */ 5,
+            /* 20 */ 1, /* 21 */ 2, /* 22 */ 2, /* 23 */ 3,
+            /* 24 */ 2, /* 25 */ 3, /* 26 */ 3, /* 27 */ 4,
+            /* 28 */ 2, /* 29 */ 3, /* 2a */ 3, /* 2b */ 4,
+            /* 2c */ 3, /* 2d */ 4, /* 2e */ 4, /* 2f */ 5,
+            /* 30 */ 2, /* 31 */ 3, /* 32 */ 3, /* 33 */ 4,
+            /* 34 */ 3, /* 35 */ 4, /* 36 */ 4, /* 37 */ 5,
+            /* 38 */ 3, /* 39 */ 4, /* 3a */ 4, /* 3b */ 5,
+            /* 3c */ 4, /* 3d */ 5, /* 3e */ 5, /* 3f */ 6,
+            /* 40 */ 1, /* 41 */ 2, /* 42 */ 2, /* 43 */ 3,
+            /* 44 */ 2, /* 45 */ 3, /* 46 */ 3, /* 47 */ 4,
+            /* 48 */ 2, /* 49 */ 3, /* 4a */ 3, /* 4b */ 4,
+            /* 4c */ 3, /* 4d */ 4, /* 4e */ 4, /* 4f */ 5,
+            /* 50 */ 2, /* 51 */ 3, /* 52 */ 3, /* 53 */ 4,
+            /* 54 */ 3, /* 55 */ 4, /* 56 */ 4, /* 57 */ 5,
+            /* 58 */ 3, /* 59 */ 4, /* 5a */ 4, /* 5b */ 5,
+            /* 5c */ 4, /* 5d */ 5, /* 5e */ 5, /* 5f */ 6,
+            /* 60 */ 2, /* 61 */ 3, /* 62 */ 3, /* 63 */ 4,
+            /* 64 */ 3, /* 65 */ 4, /* 66 */ 4, /* 67 */ 5,
+            /* 68 */ 3, /* 69 */ 4, /* 6a */ 4, /* 6b */ 5,
+            /* 6c */ 4, /* 6d */ 5, /* 6e */ 5, /* 6f */ 6,
+            /* 70 */ 3, /* 71 */ 4, /* 72 */ 4, /* 73 */ 5,
+            /* 74 */ 4, /* 75 */ 5, /* 76 */ 5, /* 77 */ 6,
+            /* 78 */ 4, /* 79 */ 5, /* 7a */ 5, /* 7b */ 6,
+            /* 7c */ 5, /* 7d */ 6, /* 7e */ 6, /* 7f */ 7,
+            /* 80 */ 1, /* 81 */ 2, /* 82 */ 2, /* 83 */ 3,
+            /* 84 */ 2, /* 85 */ 3, /* 86 */ 3, /* 87 */ 4,
+            /* 88 */ 2, /* 89 */ 3, /* 8a */ 3, /* 8b */ 4,
+            /* 8c */ 3, /* 8d */ 4, /* 8e */ 4, /* 8f */ 5,
+            /* 90 */ 2, /* 91 */ 3, /* 92 */ 3, /* 93 */ 4,
+            /* 94 */ 3, /* 95 */ 4, /* 96 */ 4, /* 97 */ 5,
+            /* 98 */ 3, /* 99 */ 4, /* 9a */ 4, /* 9b */ 5,
+            /* 9c */ 4, /* 9d */ 5, /* 9e */ 5, /* 9f */ 6,
+            /* a0 */ 2, /* a1 */ 3, /* a2 */ 3, /* a3 */ 4,
+            /* a4 */ 3, /* a5 */ 4, /* a6 */ 4, /* a7 */ 5,
+            /* a8 */ 3, /* a9 */ 4, /* aa */ 4, /* ab */ 5,
+            /* ac */ 4, /* ad */ 5, /* ae */ 5, /* af */ 6,
+            /* b0 */ 3, /* b1 */ 4, /* b2 */ 4, /* b3 */ 5,
+            /* b4 */ 4, /* b5 */ 5, /* b6 */ 5, /* b7 */ 6,
+            /* b8 */ 4, /* b9 */ 5, /* ba */ 5, /* bb */ 6,
+            /* bc */ 5, /* bd */ 6, /* be */ 6, /* bf */ 7,
+            /* c0 */ 2, /* c1 */ 3, /* c2 */ 3, /* c3 */ 4,
+            /* c4 */ 3, /* c5 */ 4, /* c6 */ 4, /* c7 */ 5,
+            /* c8 */ 3, /* c9 */ 4, /* ca */ 4, /* cb */ 5,
+            /* cc */ 4, /* cd */ 5, /* ce */ 5, /* cf */ 6,
+            /* d0 */ 3, /* d1 */ 4, /* d2 */ 4, /* d3 */ 5,
+            /* d4 */ 4, /* d5 */ 5, /* d6 */ 5, /* d7 */ 6,
+            /* d8 */ 4, /* d9 */ 5, /* da */ 5, /* db */ 6,
+            /* dc */ 5, /* dd */ 6, /* de */ 6, /* df */ 7,
+            /* e0 */ 3, /* e1 */ 4, /* e2 */ 4, /* e3 */ 5,
+            /* e4 */ 4, /* e5 */ 5, /* e6 */ 5, /* e7 */ 6,
+            /* e8 */ 4, /* e9 */ 5, /* ea */ 5, /* eb */ 6,
+            /* ec */ 5, /* ed */ 6, /* ee */ 6, /* ef */ 7,
+            /* f0 */ 4, /* f1 */ 5, /* f2 */ 5, /* f3 */ 6,
+            /* f4 */ 5, /* f5 */ 6, /* f6 */ 6, /* f7 */ 7,
+            /* f8 */ 5, /* f9 */ 6, /* fa */ 6, /* fb */ 7,
+            /* fc */ 6, /* fd */ 7, /* fe */ 7, /* ff */ 8
+        };
+        return table[b];
+    }
+};
 
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		diff0 = fabs(first1[0] - first2[0]);
-		diff1 = fabs(first1[1] - first2[1]);
-		diff2 = fabs(first1[2] - first2[2]);
-		diff3 = fabs(first1[3] - first2[3]);
-		if (diff0 > dist) dist = diff0;
-		if (diff1 > dist) dist = diff1;
-		if (diff2 > dist) dist = diff2;
-		if (diff3 > dist) dist = diff3;
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		diff0 = fabs(*first1++ - *first2++);
-		dist = (diff0 > dist) ? diff0 : dist;
-	}
-	return dist;
-}
-
-
-template <typename Iterator1, typename Iterator2>
-double hist_intersection_kernel(Iterator1 first1, Iterator1 last1, Iterator2 first2)
-{
-	double kernel = 0;
-	Iterator1 lastgroup = last1 - 3;
-	double min0, min1, min2, min3;
-
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		min0 = first1[0] < first2[0] ? first1[0] : first2[0];
-		min1 = first1[1] < first2[1] ? first1[1] : first2[1];
-		min2 = first1[2] < first2[2] ? first1[2] : first2[2];
-		min3 = first1[3] < first2[3] ? first1[3] : first2[3];
-		kernel += min0 + min1 + min2 + min3;
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		min0 = first1[0] < first2[0] ? first1[0] : first2[0];
-		kernel += min0;
-		first1++;
-		first2++;
-	}
-	return kernel;
-}
-
-template <typename Iterator1, typename Iterator2>
-double hist_intersection_dist_sq(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
-{
-	double dist_sq = acc - 2 * hist_intersection_kernel(first1, last1, first2);
-	while (first1 < last1) {
-		dist_sq += *first1 + *first2;
-		first1++;
-		first2++;
-	}
-	return dist_sq;
-}
-
-
-// Hellinger distance
-template <typename Iterator1, typename Iterator2>
-double hellinger_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
-{
-	double distsq = acc;
-	double diff0, diff1, diff2, diff3;
-	Iterator1 lastgroup = last1 - 3;
-
-	/* Process 4 items with each loop for efficiency. */
-	while (first1 < lastgroup) {
-		diff0 = sqrt(first1[0]) - sqrt(first2[0]);
-		diff1 = sqrt(first1[1]) - sqrt(first2[1]);
-		diff2 = sqrt(first1[2]) - sqrt(first2[2]);
-		diff3 = sqrt(first1[3]) - sqrt(first2[3]);
-		distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
-		first1 += 4;
-		first2 += 4;
-	}
-	/* Process last 0-3 pixels.  Not needed for standard vector lengths. */
-	while (first1 < last1) {
-		diff0 = sqrt(*first1++) - sqrt(*first2++);
-		distsq += diff0 * diff0;
-	}
-	return distsq;
-}
-
-
-// chi-dsquare distance
-template <typename Iterator1, typename Iterator2>
-double chi_square_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
-{
-	double dist = acc;
-
-	while (first1 < last1) {
-		double sum = *first1 + *first2;
-		if (sum > 0) {
-			double diff = *first1 - *first2;
-			dist += diff * diff / sum;
-		}
-		first1++;
-		first2++;
-	}
-	return dist;
-}
-
-
-// Kullback–Leibler divergence (NOT SYMMETRIC)
-template <typename Iterator1, typename Iterator2>
-double kl_divergence(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
-{
-	double div = acc;
-
-	while (first1 < last1) {
-		if (*first2 != 0) {
-			double ratio = *first1 / *first2;
-			if (ratio > 0) {
-				div += *first1 * log(ratio);
-			}
-		}
-		first1++;
-		first2++;
-	}
-	return div;
-}
-
-
-
-
-CV_EXPORTS flann_distance_t flann_distance_type();
 /**
- * Custom distance function. The distance computed is dependent on the value
- * of the 'flann_distance_type' global variable.
- *
- * If the last argument 'acc' is passed, the result is accumulated to the value
- * of this argument.
+ * Hamming distance functor (pop count between two binary vectors, i.e. xor them and count the number of bits set)
+ * That code was taken from brief.cpp in OpenCV
  */
-template <typename Iterator1, typename Iterator2>
-double custom_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0)
+template<class T>
+struct Hamming
 {
-	switch (flann_distance_type()) {
-	case FLANN_DIST_EUCLIDEAN:
-		return euclidean_dist(first1, last1, first2, acc);
-	case FLANN_DIST_MANHATTAN:
-		return manhattan_dist(first1, last1, first2, acc);
-	case FLANN_DIST_MINKOWSKI:
-		return minkowski_dist(first1, last1, first2, acc);
-	case FLANN_DIST_MAX:
-		return max_dist(first1, last1, first2, acc);
-	case FLANN_DIST_HIST_INTERSECT:
-		return hist_intersection_dist_sq(first1, last1, first2, acc);
-	case FLANN_DIST_HELLINGER:
-		return hellinger_dist(first1, last1, first2, acc);
-	case FLANN_DIST_CS:
-		return chi_square_dist(first1, last1, first2, acc);
-	case FLANN_DIST_KL:
-		return kl_divergence(first1, last1, first2, acc);
-	default:
-		return euclidean_dist(first1, last1, first2, acc);
-	}
-}
+    typedef False is_kdtree_distance;
+    typedef False is_vector_space_distance;
+
+
+    typedef T ElementType;
+    typedef int ResultType;
+
+    template<typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const
+    {
+        ResultType result = 0;
+#if __GNUC__
+#if ANDROID && HAVE_NEON
+        static uint64_t features = android_getCpuFeatures();
+        if ((features& ANDROID_CPU_ARM_FEATURE_NEON)) {
+            for (size_t i = 0; i < size; i += 16) {
+                uint8x16_t A_vec = vld1q_u8 (a + i);
+                uint8x16_t B_vec = vld1q_u8 (b + i);
+                //uint8x16_t veorq_u8 (uint8x16_t, uint8x16_t)
+                uint8x16_t AxorB = veorq_u8 (A_vec, B_vec);
+
+                uint8x16_t bitsSet += vcntq_u8 (AxorB);
+                //uint16x8_t vpadalq_u8 (uint16x8_t, uint8x16_t)
+                uint16x8_t bitSet8 = vpaddlq_u8 (bitsSet);
+                uint32x4_t bitSet4 = vpaddlq_u16 (bitSet8);
+
+                uint64x2_t bitSet2 = vpaddlq_u32 (bitSet4);
+                result += vgetq_lane_u64 (bitSet2,0);
+                result += vgetq_lane_u64 (bitSet2,1);
+            }
+        }
+        else
+#endif
+        //for portability just use unsigned long -- and use the __builtin_popcountll (see docs for __builtin_popcountll)
+        typedef unsigned long long pop_t;
+        const size_t modulo = size % sizeof(pop_t);
+        const pop_t* a2 = reinterpret_cast<const pop_t*> (a);
+        const pop_t* b2 = reinterpret_cast<const pop_t*> (b);
+        const pop_t* a2_end = a2 + (size / sizeof(pop_t));
+
+        for (; a2 != a2_end; ++a2, ++b2) result += __builtin_popcountll((*a2) ^ (*b2));
+
+        if (modulo) {
+            //in the case where size is not dividable by sizeof(size_t)
+            //need to mask off the bits at the end
+            pop_t a_final = 0, b_final = 0;
+            memcpy(&a_final, a2, modulo);
+            memcpy(&b_final, b2, modulo);
+            result += __builtin_popcountll(a_final ^ b_final);
+        }
+#else
+        HammingLUT lut;
+        result = lut(reinterpret_cast<const unsigned char*> (a),
+                     reinterpret_cast<const unsigned char*> (b), size * sizeof(pop_t));
+#endif
+        return result;
+    }
+};
+
+template<typename T>
+struct Hamming2
+{
+    typedef False is_kdtree_distance;
+    typedef False is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef int ResultType;
+
+    /** This is popcount_3() from:
+     * http://en.wikipedia.org/wiki/Hamming_weight */
+    unsigned int popcnt32(uint32_t n) const
+    {
+        n -= ((n >> 1) & 0x55555555);
+        n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
+        return (((n + (n >> 4))& 0xF0F0F0F)* 0x1010101) >> 24;
+    }
+
+#ifdef FLANN_PLATFORM_64_BIT
+    unsigned int popcnt64(uint64_t n) const
+    {
+        n -= ((n >> 1) & 0x5555555555555555);
+        n = (n & 0x3333333333333333) + ((n >> 2) & 0x3333333333333333);
+        return (((n + (n >> 4))& 0x0f0f0f0f0f0f0f0f)* 0x0101010101010101) >> 56;
+    }
+#endif
+
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const
+    {
+#ifdef FLANN_PLATFORM_64_BIT
+        const uint64_t* pa = reinterpret_cast<const uint64_t*>(a);
+        const uint64_t* pb = reinterpret_cast<const uint64_t*>(b);
+        ResultType result = 0;
+        size /= (sizeof(uint64_t)/sizeof(unsigned char));
+        for(size_t i = 0; i < size; ++i ) {
+            result += popcnt64(*pa ^ *pb);
+            ++pa;
+            ++pb;
+        }
+#else
+        const uint32_t* pa = reinterpret_cast<const uint32_t*>(a);
+        const uint32_t* pb = reinterpret_cast<const uint32_t*>(b);
+        ResultType result = 0;
+        size /= (sizeof(uint32_t)/sizeof(unsigned char));
+        for(size_t i = 0; i < size; ++i ) {
+        	result += popcnt32(*pa ^ *pb);
+        	++pa;
+        	++pb;
+        }
+#endif
+        return result;
+    }
+};
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class T>
+struct HistIntersectionDistance
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the histogram intersection distance
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType min0, min1, min2, min3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            min0 = (ResultType)(a[0] < b[0] ? a[0] : b[0]);
+            min1 = (ResultType)(a[1] < b[1] ? a[1] : b[1]);
+            min2 = (ResultType)(a[2] < b[2] ? a[2] : b[2]);
+            min3 = (ResultType)(a[3] < b[3] ? a[3] : b[3]);
+            result += min0 + min1 + min2 + min3;
+            a += 4;
+            b += 4;
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+        while (a < last) {
+            min0 = (ResultType)(*a < *b ? *a : *b);
+            result += min0;
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        return a<b ? a : b;
+    }
+};
+
+
+
+template<class T>
+struct HellingerDistance
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the histogram intersection distance
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType diff0, diff1, diff2, diff3;
+        Iterator1 last = a + size;
+        Iterator1 lastgroup = last - 3;
+
+        /* Process 4 items with each loop for efficiency. */
+        while (a < lastgroup) {
+            diff0 = sqrt(static_cast<ResultType>(a[0])) - sqrt(static_cast<ResultType>(b[0]));
+            diff1 = sqrt(static_cast<ResultType>(a[1])) - sqrt(static_cast<ResultType>(b[1]));
+            diff2 = sqrt(static_cast<ResultType>(a[2])) - sqrt(static_cast<ResultType>(b[2]));
+            diff3 = sqrt(static_cast<ResultType>(a[3])) - sqrt(static_cast<ResultType>(b[3]));
+            result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
+            a += 4;
+            b += 4;
+        }
+        while (a < last) {
+            diff0 = sqrt(static_cast<ResultType>(*a++)) - sqrt(static_cast<ResultType>(*b++));
+            result += diff0 * diff0;
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    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));
+    }
+};
+
+
+template<class T>
+struct ChiSquareDistance
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the chi-square distance
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        ResultType sum, diff;
+        Iterator1 last = a + size;
+
+        while (a < last) {
+            sum = (ResultType)(*a + *b);
+            if (sum>0) {
+                diff = (ResultType)(*a - *b);
+                result += diff*diff/sum;
+            }
+            ++a;
+            ++b;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        ResultType result = ResultType();
+        ResultType sum, diff;
+
+        sum = (ResultType)(a+b);
+        if (sum>0) {
+            diff = (ResultType)(a-b);
+            result = diff*diff/sum;
+        }
+        return result;
+    }
+};
+
+
+template<class T>
+struct KL_Divergence
+{
+    typedef True is_kdtree_distance;
+    typedef True is_vector_space_distance;
+
+    typedef T ElementType;
+    typedef typename Accumulator<T>::Type ResultType;
+
+    /**
+     *  Compute the Kullback–Leibler divergence
+     */
+    template <typename Iterator1, typename Iterator2>
+    ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
+    {
+        ResultType result = ResultType();
+        Iterator1 last = a + size;
+
+        while (a < last) {
+            if (* a != 0) {
+                ResultType ratio = (ResultType)(*a / *b);
+                if (ratio>0) {
+                    result += *a * log(ratio);
+                }
+            }
+            ++a;
+            ++b;
+
+            if ((worst_dist>0)&&(result>worst_dist)) {
+                return result;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Partial distance, used by the kd-tree.
+     */
+    template <typename U, typename V>
+    inline ResultType accum_dist(const U& a, const V& b, int) const
+    {
+        ResultType result = ResultType();
+        ResultType ratio = (ResultType)(a / b);
+        if (ratio>0) {
+            result = a * log(ratio);
+        }
+        return result;
+    }
+};
+
+
 
 /*
  * This is a "zero iterator". It basically behaves like a zero filled
@@ -333,28 +808,36 @@ double custom_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double a
  * zero-filled array.
  */
 template <typename T>
-struct ZeroIterator {
+struct ZeroIterator
+{
 
-	T operator*() {
-		return 0;
-	}
+    T operator*()
+    {
+        return 0;
+    }
 
-	T operator[](int) {
-		return 0;
-	}
+    T operator[](int)
+    {
+        return 0;
+    }
 
-	ZeroIterator<T>& operator ++(int) {
-		return *this;
-	}
+    const ZeroIterator<T>& operator ++()
+    {
+        return *this;
+    }
 
-	ZeroIterator<T>& operator+=(int) {
-		return *this;
-	}
+    ZeroIterator<T> operator ++(int)
+    {
+        return *this;
+    }
+
+    ZeroIterator<T>& operator+=(int)
+    {
+        return *this;
+    }
 
 };
 
-CV_EXPORTS ZeroIterator<float>& zero();
+}
 
-} // namespace cvflann
-
-#endif //_OPENCV_DIST_H_
+#endif //OPENCV_FLANN_DIST_H_
diff --git a/modules/flann/include/opencv2/flann/dummy.h b/modules/flann/include/opencv2/flann/dummy.h
new file mode 100644
index 0000000000..26bd3fa5dd
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/dummy.h
@@ -0,0 +1,16 @@
+
+#ifndef OPENCV_FLANN_DUMMY_H_
+#define OPENCV_FLANN_DUMMY_H_
+
+namespace cvflann
+{
+
+#if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
+__declspec(dllexport)
+#endif
+void dummyfunc();
+
+}
+
+
+#endif  /* OPENCV_FLANN_DUMMY_H_ */
diff --git a/modules/flann/include/opencv2/flann/dynamic_bitset.h b/modules/flann/include/opencv2/flann/dynamic_bitset.h
new file mode 100644
index 0000000000..e88cfaa167
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/dynamic_bitset.h
@@ -0,0 +1,152 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *************************************************************************/
+
+/***********************************************************************
+ * Author: Vincent Rabaud
+ *************************************************************************/
+
+#ifndef OPENCV_FLANN_DYNAMIC_BITSET_H_
+#define OPENCV_FLANN_DYNAMIC_BITSET_H_
+
+//#define FLANN_USE_BOOST 1
+#if FLANN_USE_BOOST
+#include <boost/dynamic_bitset.hpp>
+typedef boost::dynamic_bitset<> DynamicBitset;
+#else
+
+#include <limits.h>
+
+#include "dist.h"
+
+/** Class re-implementing the boost version of it
+ * This helps not depending on boost, it also does not do the bound checks
+ * and has a way to reset a block for speed
+ */
+class DynamicBitset
+{
+public:
+    /** @param default constructor
+     */
+    DynamicBitset()
+    {
+    }
+
+    /** @param only constructor we use in our code
+     * @param the size of the bitset (in bits)
+     */
+    DynamicBitset(size_t size)
+    {
+        resize(size);
+        reset();
+    }
+
+    /** Sets all the bits to 0
+     */
+    void clear()
+    {
+        std::fill(bitset_.begin(), bitset_.end(), 0);
+    }
+
+    /** @brief checks if the bitset is empty
+     * @return true if the bitset is empty
+     */
+    bool empty() const
+    {
+        return bitset_.empty();
+    }
+
+    /** @param set all the bits to 0
+     */
+    void reset()
+    {
+        std::fill(bitset_.begin(), bitset_.end(), 0);
+    }
+
+    /** @brief set one bit to 0
+     * @param
+     */
+    void reset(size_t index)
+    {
+        bitset_[index / cell_bit_size_] &= ~(size_t(1) << (index % cell_bit_size_));
+    }
+
+    /** @brief sets a specific bit to 0, and more bits too
+     * This function is useful when resetting a given set of bits so that the
+     * whole bitset ends up being 0: if that's the case, we don't care about setting
+     * other bits to 0
+     * @param
+     */
+    void reset_block(size_t index)
+    {
+        bitset_[index / cell_bit_size_] = 0;
+    }
+
+    /** @param resize the bitset so that it contains at least size bits
+     * @param size
+     */
+    void resize(size_t size)
+    {
+        size_ = size;
+        bitset_.resize(size / cell_bit_size_ + 1);
+    }
+
+    /** @param set a bit to true
+     * @param index the index of the bit to set to 1
+     */
+    void set(size_t index)
+    {
+        bitset_[index / cell_bit_size_] |= size_t(1) << (index % cell_bit_size_);
+    }
+
+    /** @param gives the number of contained bits
+     */
+    size_t size() const
+    {
+        return size_;
+    }
+
+    /** @param check if a bit is set
+     * @param index the index of the bit to check
+     * @return true if the bit is set
+     */
+    bool test(size_t index) const
+    {
+        return (bitset_[index / cell_bit_size_] & (size_t(1) << (index % cell_bit_size_))) != 0;
+    }
+
+private:
+    std::vector<size_t> bitset_;
+    size_t size_;
+    static const unsigned int cell_bit_size_ = CHAR_BIT * sizeof(size_t);
+};
+
+#endif
+
+#endif // OPENCV_FLANN_DYNAMIC_BITSET_H_
diff --git a/modules/flann/include/opencv2/flann/flann.hpp b/modules/flann/include/opencv2/flann/flann.hpp
index 642b17be66..988988f286 100644
--- a/modules/flann/include/opencv2/flann/flann.hpp
+++ b/modules/flann/include/opencv2/flann/flann.hpp
@@ -45,7 +45,17 @@
 
 #ifdef __cplusplus
 
+#include "opencv2/core/types_c.h"
+#include "opencv2/core/core.hpp"
 #include "opencv2/flann/flann_base.hpp"
+#include "opencv2/flann/miniflann.hpp"
+
+namespace cvflann
+{
+    CV_EXPORTS flann_distance_t flann_distance_type();
+    FLANN_DEPRECATED CV_EXPORTS void set_distance_type(flann_distance_t distance_type, int order);
+}
+
 
 namespace cv
 {
@@ -61,132 +71,345 @@ template <> struct CvType<int> { static int type() { return CV_32S; } };
 template <> struct CvType<float> { static int type() { return CV_32F; } };
 template <> struct CvType<double> { static int type() { return CV_64F; } };
 
-    
-using ::cvflann::IndexParams;
-using ::cvflann::LinearIndexParams;
-using ::cvflann::KDTreeIndexParams;
-using ::cvflann::KMeansIndexParams;
-using ::cvflann::CompositeIndexParams;
-using ::cvflann::AutotunedIndexParams;
-using ::cvflann::SavedIndexParams;
 
-using ::cvflann::SearchParams;
+// bring the flann parameters into this namespace
+using ::cvflann::get_param;
+using ::cvflann::print_params;
+
+// bring the flann distances into this namespace
+using ::cvflann::L2_Simple;
+using ::cvflann::L2;
+using ::cvflann::L1;
+using ::cvflann::MinkowskiDistance;
+using ::cvflann::MaxDistance;
+using ::cvflann::HammingLUT;
+using ::cvflann::Hamming;
+using ::cvflann::Hamming2;
+using ::cvflann::HistIntersectionDistance;
+using ::cvflann::HellingerDistance;
+using ::cvflann::ChiSquareDistance;
+using ::cvflann::KL_Divergence;
 
 
-template <typename T>
-class CV_EXPORTS Index_ {
-	::cvflann::Index<T>* nnIndex;
 
+template <typename Distance>
+class GenericIndex 
+{
 public:
-	Index_(const Mat& features, const IndexParams& params);
+        typedef typename Distance::ElementType ElementType;
+        typedef typename Distance::ResultType DistanceType;
+
+        GenericIndex(const Mat& features, const ::cvflann::IndexParams& params, Distance distance = Distance());
+
+        ~GenericIndex();
+
+        void knnSearch(const vector<ElementType>& query, vector<int>& indices, 
+                       vector<DistanceType>& dists, int knn, const ::cvflann::SearchParams& params);
+        void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const ::cvflann::SearchParams& params);
+
+        int radiusSearch(const vector<ElementType>& query, vector<int>& indices, 
+                         vector<DistanceType>& dists, DistanceType radius, const ::cvflann::SearchParams& params);
+        int radiusSearch(const Mat& query, Mat& indices, Mat& dists, 
+                         DistanceType radius, const ::cvflann::SearchParams& params);
+
+        void save(std::string filename) { nnIndex->save(filename); }
+
+        int veclen() const { return nnIndex->veclen(); }
+
+        int size() const { return nnIndex->size(); }
+
+        ::cvflann::IndexParams getParameters() { return nnIndex->getParameters(); }
+
+        FLANN_DEPRECATED const ::cvflann::IndexParams* getIndexParameters() { return nnIndex->getIndexParameters(); }
+
+private:
+        ::cvflann::Index<Distance>* nnIndex;
+};
+
+
+#define FLANN_DISTANCE_CHECK \
+    if ( ::cvflann::flann_distance_type() != cvflann::FLANN_DIST_L2) { \
+        printf("[WARNING] You are using cv::flann::Index (or cv::flann::GenericIndex) and have also changed "\
+        "the distance using cvflann::set_distance_type. This is no longer working as expected "\
+        "(cv::flann::Index always uses L2). You should create the index templated on the distance, "\
+        "for example for L1 distance use: GenericIndex< L1<float> > \n"); \
+    }
+    
+
+template <typename Distance>
+GenericIndex<Distance>::GenericIndex(const Mat& dataset, const ::cvflann::IndexParams& params, Distance distance)
+{
+    CV_Assert(dataset.type() == CvType<ElementType>::type());
+    CV_Assert(dataset.isContinuous());
+    ::cvflann::Matrix<ElementType> m_dataset((ElementType*)dataset.ptr<ElementType>(0), dataset.rows, dataset.cols);
+    
+    nnIndex = new ::cvflann::Index<Distance>(m_dataset, params, distance);
+    
+    FLANN_DISTANCE_CHECK
+    
+    nnIndex->buildIndex();
+}
+
+template <typename Distance>
+GenericIndex<Distance>::~GenericIndex()
+{
+    delete nnIndex;
+}
+
+template <typename Distance>
+void GenericIndex<Distance>::knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const ::cvflann::SearchParams& searchParams)
+{
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
+    ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
+    ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
+
+    FLANN_DISTANCE_CHECK
+
+    nnIndex->knnSearch(m_query,m_indices,m_dists,knn,searchParams);
+}
+
+
+template <typename Distance>
+void GenericIndex<Distance>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const ::cvflann::SearchParams& searchParams)
+{
+    CV_Assert(queries.type() == CvType<ElementType>::type());
+    CV_Assert(queries.isContinuous());
+    ::cvflann::Matrix<ElementType> m_queries((ElementType*)queries.ptr<ElementType>(0), queries.rows, queries.cols);
+    
+    CV_Assert(indices.type() == CV_32S);
+    CV_Assert(indices.isContinuous());
+    ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
+    
+    CV_Assert(dists.type() == CvType<DistanceType>::type());
+    CV_Assert(dists.isContinuous());
+    ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
+
+    FLANN_DISTANCE_CHECK
+    
+    nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
+}
+
+template <typename Distance>
+int GenericIndex<Distance>::radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, DistanceType radius, const ::cvflann::SearchParams& searchParams)
+{
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
+    ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
+    ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
+
+    FLANN_DISTANCE_CHECK
+    
+    return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+}
+
+template <typename Distance>
+int GenericIndex<Distance>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& searchParams)
+{
+    CV_Assert(query.type() == CvType<ElementType>::type());
+    CV_Assert(query.isContinuous());
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)query.ptr<ElementType>(0), query.rows, query.cols);
+    
+    CV_Assert(indices.type() == CV_32S);
+    CV_Assert(indices.isContinuous());
+    ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
+    
+    CV_Assert(dists.type() == CvType<DistanceType>::type());
+    CV_Assert(dists.isContinuous());
+    ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
+    
+    FLANN_DISTANCE_CHECK
+    
+    return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+}
+
+/**
+ * @deprecated Use GenericIndex class instead
+ */
+template <typename T>
+class FLANN_DEPRECATED Index_ {
+public:
+        typedef typename L2<T>::ElementType ElementType;
+        typedef typename L2<T>::ResultType DistanceType;
+
+	Index_(const Mat& features, const ::cvflann::IndexParams& params);
 
 	~Index_();
 
-	void knnSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, int knn, const SearchParams& params);
-	void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params);
+	void knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const ::cvflann::SearchParams& params);
+	void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const ::cvflann::SearchParams& params);
 
-	int radiusSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, float radius, const SearchParams& params);
-	int radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& params);
+	int radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, DistanceType radius, const ::cvflann::SearchParams& params);
+	int radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& params);
 
-	void save(std::string filename) { nnIndex->save(filename); }
+	void save(std::string filename) 
+        { 
+            if (nnIndex_L1) nnIndex_L1->save(filename);
+            if (nnIndex_L2) nnIndex_L2->save(filename);
+        }
 
-	int veclen() const { return nnIndex->veclen(); }
+	int veclen() const 
+	{ 
+            if (nnIndex_L1) return nnIndex_L1->veclen();
+            if (nnIndex_L2) return nnIndex_L2->veclen();            
+        }
 
-	int size() const { return nnIndex->size(); }
+	int size() const 
+	{ 
+            if (nnIndex_L1) return nnIndex_L1->size();
+            if (nnIndex_L2) return nnIndex_L2->size(); 
+        }
 
-	const IndexParams* getIndexParameters() { return nnIndex->getIndexParameters(); }
+        ::cvflann::IndexParams getParameters() 
+        { 
+            if (nnIndex_L1) return nnIndex_L1->getParameters();
+            if (nnIndex_L2) return nnIndex_L2->getParameters();
+            
+        }
 
+        FLANN_DEPRECATED const ::cvflann::IndexParams* getIndexParameters() 
+        { 
+            if (nnIndex_L1) return nnIndex_L1->getIndexParameters();
+            if (nnIndex_L2) return nnIndex_L2->getIndexParameters(); 
+        }
+
+private:
+        // providing backwards compatibility for L2 and L1 distances (most common)
+        ::cvflann::Index< L2<ElementType> >* nnIndex_L2;
+        ::cvflann::Index< L1<ElementType> >* nnIndex_L1;
 };
 
 
 template <typename T>
-Index_<T>::Index_(const Mat& dataset, const IndexParams& params)
+Index_<T>::Index_(const Mat& dataset, const ::cvflann::IndexParams& params)
 {
-    CV_Assert(dataset.type() == CvType<T>::type());
-    CV_Assert(dataset.isContinuous());
-    ::cvflann::Matrix<T> m_dataset((T*)dataset.ptr<T>(0), dataset.rows, dataset.cols);
+    printf("[WARNING] The cv::flann::Index_<T> class is deperecated, use cv::flann::GenericIndex<Distance> instead\n");
     
-    nnIndex = new ::cvflann::Index<T>(m_dataset, params);
-    nnIndex->buildIndex();
+    CV_Assert(dataset.type() == CvType<ElementType>::type());
+    CV_Assert(dataset.isContinuous());
+    ::cvflann::Matrix<ElementType> m_dataset((ElementType*)dataset.ptr<ElementType>(0), dataset.rows, dataset.cols);
+    
+    if ( ::cvflann::flann_distance_type() == cvflann::FLANN_DIST_L2 ) {
+        nnIndex_L1 = NULL;
+        nnIndex_L2 = new ::cvflann::Index< L2<ElementType> >(m_dataset, params);
+    }
+    else if ( ::cvflann::flann_distance_type() == cvflann::FLANN_DIST_L1 ) {
+        nnIndex_L1 = new ::cvflann::Index< L1<ElementType> >(m_dataset, params);
+        nnIndex_L2 = NULL;        
+    }
+    else {
+        printf("[ERROR] cv::flann::Index_<T> only provides backwards compatibility for the L1 and L2 distances. "
+        "For other distance types you must use cv::flann::GenericIndex<Distance>\n");
+        CV_Assert(0);
+    }
+    if (nnIndex_L1) nnIndex_L1->buildIndex();
+    if (nnIndex_L2) nnIndex_L2->buildIndex();
 }
 
 template <typename T>
 Index_<T>::~Index_()
 {
-    delete nnIndex;
+    if (nnIndex_L1) delete nnIndex_L1;
+    if (nnIndex_L2) delete nnIndex_L2;
 }
 
 template <typename T>
-void Index_<T>::knnSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, int knn, const SearchParams& searchParams)
+void Index_<T>::knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const ::cvflann::SearchParams& searchParams)
 {
-    ::cvflann::Matrix<T> m_query((T*)&query[0], 1, (int)query.size());
-    ::cvflann::Matrix<int> m_indices(&indices[0], 1, (int)indices.size());
-    ::cvflann::Matrix<float> m_dists(&dists[0], 1, (int)dists.size());
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
+    ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
+    ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
     
-    nnIndex->knnSearch(m_query,m_indices,m_dists,knn,searchParams);
+    if (nnIndex_L1) nnIndex_L1->knnSearch(m_query,m_indices,m_dists,knn,searchParams);
+    if (nnIndex_L2) nnIndex_L2->knnSearch(m_query,m_indices,m_dists,knn,searchParams);
 }
 
 
 template <typename T>
-void Index_<T>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams)
+void Index_<T>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const ::cvflann::SearchParams& searchParams)
 {
-    CV_Assert(queries.type() == CvType<T>::type());
+    CV_Assert(queries.type() == CvType<ElementType>::type());
     CV_Assert(queries.isContinuous());
-    ::cvflann::Matrix<T> m_queries((T*)queries.ptr<T>(0), queries.rows, queries.cols);
+    ::cvflann::Matrix<ElementType> m_queries((ElementType*)queries.ptr<ElementType>(0), queries.rows, queries.cols);
     
     CV_Assert(indices.type() == CV_32S);
     CV_Assert(indices.isContinuous());
     ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
     
-    CV_Assert(dists.type() == CV_32F);
+    CV_Assert(dists.type() == CvType<DistanceType>::type());
     CV_Assert(dists.isContinuous());
-    ::cvflann::Matrix<float> m_dists((float*)dists.ptr<float>(0), dists.rows, dists.cols);
-    
-    nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
+    ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
+
+    if (nnIndex_L1) nnIndex_L1->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
+    if (nnIndex_L2) nnIndex_L2->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
 }
 
 template <typename T>
-int Index_<T>::radiusSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, float radius, const SearchParams& searchParams)
+int Index_<T>::radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, DistanceType radius, const ::cvflann::SearchParams& searchParams)
 {
-    ::cvflann::Matrix<T> m_query((T*)&query[0], 1, (int)query.size());
-    ::cvflann::Matrix<int> m_indices(&indices[0], 1, (int)indices.size());
-    ::cvflann::Matrix<float> m_dists(&dists[0], 1, (int)dists.size());
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
+    ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
+    ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
     
-    return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+    if (nnIndex_L1) return nnIndex_L1->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+    if (nnIndex_L2) return nnIndex_L2->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
 }
 
 template <typename T>
-int Index_<T>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& searchParams)
+int Index_<T>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const ::cvflann::SearchParams& searchParams)
 {
-    CV_Assert(query.type() == CvType<T>::type());
+    CV_Assert(query.type() == CvType<ElementType>::type());
     CV_Assert(query.isContinuous());
-    ::cvflann::Matrix<T> m_query((T*)query.ptr<T>(0), query.rows, query.cols);
+    ::cvflann::Matrix<ElementType> m_query((ElementType*)query.ptr<ElementType>(0), query.rows, query.cols);
     
     CV_Assert(indices.type() == CV_32S);
     CV_Assert(indices.isContinuous());
     ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
     
-    CV_Assert(dists.type() == CV_32F);
+    CV_Assert(dists.type() == CvType<DistanceType>::type());
     CV_Assert(dists.isContinuous());
-    ::cvflann::Matrix<float> m_dists((float*)dists.ptr<float>(0), dists.rows, dists.cols);
+    ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
     
-    return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+    if (nnIndex_L1) return nnIndex_L1->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+    if (nnIndex_L2) return nnIndex_L2->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
+}
+
+
+template <typename Distance>
+int hierarchicalClustering(const Mat& features, Mat& centers, const ::cvflann::IndexParams& params,
+                           Distance d = Distance())
+{
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+    
+    CV_Assert(features.type() == CvType<ElementType>::type());
+    CV_Assert(features.isContinuous());
+    ::cvflann::Matrix<ElementType> m_features((ElementType*)features.ptr<ElementType>(0), features.rows, features.cols);
+    
+    CV_Assert(centers.type() == CvType<DistanceType>::type());
+    CV_Assert(centers.isContinuous());
+    ::cvflann::Matrix<DistanceType> m_centers((DistanceType*)centers.ptr<DistanceType>(0), centers.rows, centers.cols);
+
+    return ::cvflann::hierarchicalClustering<Distance>(m_features, m_centers, params, d);
 }
 
-typedef Index_<float> Index;
 
 template <typename ELEM_TYPE, typename DIST_TYPE>
-int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params)
+FLANN_DEPRECATED int hierarchicalClustering(const Mat& features, Mat& centers, const ::cvflann::IndexParams& params)
 {
-    CV_Assert(features.type() == CvType<ELEM_TYPE>::type());
-    CV_Assert(features.isContinuous());
-    ::cvflann::Matrix<ELEM_TYPE> m_features((ELEM_TYPE*)features.ptr<ELEM_TYPE>(0), features.rows, features.cols);
-    
-    CV_Assert(centers.type() == CvType<DIST_TYPE>::type());
-    CV_Assert(centers.isContinuous());
-    ::cvflann::Matrix<DIST_TYPE> m_centers((DIST_TYPE*)centers.ptr<DIST_TYPE>(0), centers.rows, centers.cols);
-    
-    return ::cvflann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE>(m_features, m_centers, params);
+    printf("[WARNING] cv::flann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE> is deprecated, use "
+        "cv::flann::hierarchicalClustering<Distance> instead\n");
+        
+    if ( ::cvflann::flann_distance_type() == cvflann::FLANN_DIST_L2 ) {
+        return hierarchicalClustering< L2<ELEM_TYPE> >(features, centers, params);
+    }
+    else if ( ::cvflann::flann_distance_type() == cvflann::FLANN_DIST_L1 ) {
+        return hierarchicalClustering< L1<ELEM_TYPE> >(features, centers, params);
+    }
+    else {
+        printf("[ERROR] cv::flann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE> only provides backwards "
+        "compatibility for the L1 and L2 distances. "
+        "For other distance types you must use cv::flann::hierarchicalClustering<Distance>\n");
+        CV_Assert(0);
+    }
 }
 
 } } // namespace cv::flann
diff --git a/modules/flann/include/opencv2/flann/flann_base.hpp b/modules/flann/include/opencv2/flann/flann_base.hpp
index 46143df267..04262622bc 100644
--- a/modules/flann/include/opencv2/flann/flann_base.hpp
+++ b/modules/flann/include/opencv2/flann/flann_base.hpp
@@ -28,232 +28,264 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_FLANN_BASE_HPP_
-#define _OPENCV_FLANN_BASE_HPP_
+#ifndef FLANN_BASE_HPP_
+#define FLANN_BASE_HPP_
 
 #include <vector>
 #include <string>
 #include <cassert>
 #include <cstdio>
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/matrix.h"
-#include "opencv2/flann/result_set.h"
-#include "opencv2/flann/index_testing.h"
-#include "opencv2/flann/object_factory.h"
-#include "opencv2/flann/saving.h"
+#include "general.h"
+#include "matrix.h"
+#include "params.h"
+#include "saving.h"
 
-#include "opencv2/flann/all_indices.h"
+#include "all_indices.h"
 
 namespace cvflann
 {
 
-
 /**
-Sets the log level used for all flann functions
-
-Params:
-    level = verbosity level
-*/
-CV_EXPORTS void log_verbosity(int level);
-
-
-/**
- * Sets the distance type to use throughout FLANN.
- * If distance type specified is MINKOWSKI, the second argument
- * specifies which order the minkowski distance should have.
+ * Sets the log level used for all flann functions
+ * @param level Verbosity level
  */
-CV_EXPORTS void set_distance_type(flann_distance_t distance_type, int order);
+inline void log_verbosity(int level)
+{
+    if (level >= 0) {
+        Logger::setLevel(level);
+    }
+}
 
-
-struct CV_EXPORTS SavedIndexParams : public IndexParams {
-	SavedIndexParams(std::string filename_) : IndexParams(FLANN_INDEX_SAVED), filename(filename_) {}
-
-	std::string filename;		// filename of the stored index
-
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-		logger().info("Filename: %s\n", filename.c_str());
-	}
+/**
+ * (Deprecated) Index parameters for creating a saved index.
+ */
+struct SavedIndexParams : public IndexParams
+{
+    SavedIndexParams(std::string filename)
+    {
+        (* this)["algorithm"] = FLANN_INDEX_SAVED;
+        (*this)["filename"] = filename;
+    }
 };
 
-template<typename T>
-class CV_EXPORTS Index {
-	NNIndex<T>* nnIndex;
-    bool built;
 
+template<typename Distance>
+NNIndex<Distance>* load_saved_index(const Matrix<typename Distance::ElementType>& dataset, const std::string& filename, Distance distance)
+{
+    typedef typename Distance::ElementType ElementType;
+
+    FILE* fin = fopen(filename.c_str(), "rb");
+    if (fin == NULL) {
+        return NULL;
+    }
+    IndexHeader header = load_header(fin);
+    if (header.data_type != Datatype<ElementType>::type()) {
+        throw FLANNException("Datatype of saved index is different than of the one to be created.");
+    }
+    if ((size_t(header.rows) != dataset.rows)||(size_t(header.cols) != dataset.cols)) {
+        throw FLANNException("The index saved belongs to a different dataset");
+    }
+
+    IndexParams params;
+    params["algorithm"] = header.index_type;
+    NNIndex<Distance>* nnIndex = create_index_by_type<Distance>(dataset, params, distance);
+    nnIndex->loadIndex(fin);
+    fclose(fin);
+
+    return nnIndex;
+}
+
+
+template<typename Distance>
+class Index : public NNIndex<Distance>
+{
 public:
-	Index(const Matrix<T>& features, const IndexParams& params);
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
 
-	~Index();
+    Index(const Matrix<ElementType>& features, const IndexParams& params, Distance distance = Distance() )
+        : index_params_(params)
+    {
+        flann_algorithm_t index_type = get_param<flann_algorithm_t>(params,"algorithm");
+        loaded_ = false;
 
-	void buildIndex();
+        if (index_type == FLANN_INDEX_SAVED) {
+            nnIndex_ = load_saved_index<Distance>(features, get_param<std::string>(params,"filename"), distance);
+            loaded_ = true;
+        }
+        else {
+            nnIndex_ = create_index_by_type<Distance>(features, params, distance);
+        }
+    }
 
-	void knnSearch(const Matrix<T>& queries, Matrix<int>& indices, Matrix<float>& dists, int knn, const SearchParams& params);
+    ~Index()
+    {
+        delete nnIndex_;
+    }
 
-	int radiusSearch(const Matrix<T>& query, Matrix<int>& indices, Matrix<float>& dists, float radius, const SearchParams& params);
+    /**
+     * Builds the index.
+     */
+    void buildIndex()
+    {
+        if (!loaded_) {
+            nnIndex_->buildIndex();
+        }
+    }
 
-	void save(std::string filename);
+    void save(std::string filename)
+    {
+        FILE* fout = fopen(filename.c_str(), "wb");
+        if (fout == NULL) {
+            throw FLANNException("Cannot open file");
+        }
+        save_header(fout, *nnIndex_);
+        saveIndex(fout);
+        fclose(fout);
+    }
 
-	int veclen() const;
+    /**
+     * \brief Saves the index to a stream
+     * \param stream The stream to save the index to
+     */
+    virtual void saveIndex(FILE* stream)
+    {
+        nnIndex_->saveIndex(stream);
+    }
 
-	int size() const;
+    /**
+     * \brief Loads the index from a stream
+     * \param stream The stream from which the index is loaded
+     */
+    virtual void loadIndex(FILE* stream)
+    {
+        nnIndex_->loadIndex(stream);
+    }
 
-	NNIndex<T>* getIndex() { return nnIndex; }
+    /**
+     * \returns number of features in this index.
+     */
+    size_t veclen() const
+    {
+        return nnIndex_->veclen();
+    }
 
-	const IndexParams* getIndexParameters() { return nnIndex->getParameters(); }
+    /**
+     * \returns The dimensionality of the features in this index.
+     */
+    size_t size() const
+    {
+        return nnIndex_->size();
+    }
+
+    /**
+     * \returns The index type (kdtree, kmeans,...)
+     */
+    flann_algorithm_t getType() const
+    {
+        return nnIndex_->getType();
+    }
+
+    /**
+     * \returns The amount of memory (in bytes) used by the index.
+     */
+    virtual int usedMemory() const
+    {
+        return nnIndex_->usedMemory();
+    }
+
+
+    /**
+     * \returns The index parameters
+     */
+    IndexParams getParameters() const
+    {
+        return nnIndex_->getParameters();
+    }
+
+    /**
+     * \brief Perform k-nearest neighbor search
+     * \param[in] queries The query points for which to find the nearest neighbors
+     * \param[out] indices The indices of the nearest neighbors found
+     * \param[out] dists Distances to the nearest neighbors found
+     * \param[in] knn Number of nearest neighbors to return
+     * \param[in] params Search parameters
+     */
+    void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
+    {
+        nnIndex_->knnSearch(queries, indices, dists, knn, params);
+    }
+
+    /**
+     * \brief Perform radius search
+     * \param[in] query The query point
+     * \param[out] indices The indinces of the neighbors found within the given radius
+     * \param[out] dists The distances to the nearest neighbors found
+     * \param[in] radius The radius used for search
+     * \param[in] params Search parameters
+     * \returns Number of neighbors found
+     */
+    int radiusSearch(const Matrix<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& dists, float radius, const SearchParams& params)
+    {
+        return nnIndex_->radiusSearch(query, indices, dists, radius, params);
+    }
+
+    /**
+     * \brief Method that searches for nearest-neighbours
+     */
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+    {
+        nnIndex_->findNeighbors(result, vec, searchParams);
+    }
+
+    /**
+     * \brief Returns actual index
+     */
+    FLANN_DEPRECATED NNIndex<Distance>* getIndex()
+    {
+        return nnIndex_;
+    }
+
+    /**
+     * \brief Returns index parameters.
+     * \deprecated use getParameters() instead.
+     */
+    FLANN_DEPRECATED  const IndexParams* getIndexParameters()
+    {
+        return &index_params_;
+    }
+
+private:
+    /** Pointer to actual index class */
+    NNIndex<Distance>* nnIndex_;
+    /** Indices if the index was loaded from a file */
+    bool loaded_;
+    /** Parameters passed to the index */
+    IndexParams index_params_;
 };
 
-
-template<typename T>
-NNIndex<T>* load_saved_index(const Matrix<T>& dataset, const std::string& filename)
+/**
+ * Performs a hierarchical clustering of the points passed as argument and then takes a cut in the
+ * the clustering tree to return a flat clustering.
+ * @param[in] points Points to be clustered
+ * @param centers The computed cluster centres. Matrix should be preallocated and centers.rows is the
+ *  number of clusters requested.
+ * @param params Clustering parameters (The same as for cvflann::KMeansIndex)
+ * @param d Distance to be used for clustering (eg: cvflann::L2)
+ * @return number of clusters computed (can be different than clusters.rows and is the highest number
+ * of the form (branching-1)*K+1 smaller than clusters.rows).
+ */
+template <typename Distance>
+int hierarchicalClustering(const Matrix<typename Distance::ElementType>& points, Matrix<typename Distance::ResultType>& centers,
+                           const KMeansIndexParams& params, Distance d = Distance())
 {
-	FILE* fin = fopen(filename.c_str(), "rb");
-	if (fin==NULL) {
-		return NULL;
-	}
-	IndexHeader header = load_header(fin);
-	if (header.data_type!=Datatype<T>::type()) {
-		throw FLANNException("Datatype of saved index is different than of the one to be created.");
-	}
-	if (size_t(header.rows)!=dataset.rows || size_t(header.cols)!=dataset.cols) {
-		throw FLANNException("The index saved belongs to a different dataset");
-	}
-
-	IndexParams* params = ParamsFactory_instance().create(header.index_type);
-	NNIndex<T>* nnIndex = create_index_by_type(dataset, *params);
-	nnIndex->loadIndex(fin);
-	fclose(fin);
-
-	return nnIndex;
-}
-
-
-template<typename T>
-Index<T>::Index(const Matrix<T>& dataset, const IndexParams& params)
-{
-	flann_algorithm_t index_type = params.getIndexType();
-    built = false;
-
-	if (index_type==FLANN_INDEX_SAVED) {
-		nnIndex = load_saved_index(dataset, ((const SavedIndexParams&)params).filename);
-        built = true;
-	}
-	else {
-		nnIndex = create_index_by_type(dataset, params);
-	}
-}
-
-template<typename T>
-Index<T>::~Index()
-{
-	delete nnIndex;
-}
-
-template<typename T>
-void Index<T>::buildIndex()
-{
-	if (!built)	{
-		nnIndex->buildIndex();
-		built = true;
-	}
-}
-
-template<typename T>
-void Index<T>::knnSearch(const Matrix<T>& queries, Matrix<int>& indices, Matrix<float>& dists, int knn, const SearchParams& searchParams)
-{
-    if (!built) {
-        throw FLANNException("You must build the index before searching.");
-    }
-	assert(queries.cols==nnIndex->veclen());
-	assert(indices.rows>=queries.rows);
-	assert(dists.rows>=queries.rows);
-	assert(int(indices.cols)>=knn);
-	assert(int(dists.cols)>=knn);
-
-    KNNResultSet<T> resultSet(knn);
-
-    for (size_t i = 0; i < queries.rows; i++) {
-        T* target = queries[i];
-        resultSet.init(target, (int)queries.cols);
-
-        nnIndex->findNeighbors(resultSet, target, searchParams);
-
-        int* neighbors = resultSet.getNeighbors();
-        float* distances = resultSet.getDistances();
-        memcpy(indices[i], neighbors, knn*sizeof(int));
-        memcpy(dists[i], distances, knn*sizeof(float));
-    }
-}
-
-template<typename T>
-int Index<T>::radiusSearch(const Matrix<T>& query, Matrix<int>& indices, Matrix<float>& dists, float radius, const SearchParams& searchParams)
-{
-    if (!built) {
-        throw FLANNException("You must build the index before searching.");
-    }
-	if (query.rows!=1) {
-	    fprintf(stderr, "I can only search one feature at a time for range search\n");
-		return -1;
-	}
-	assert(query.cols==nnIndex->veclen());
-
-	RadiusResultSet<T> resultSet(radius);
-	resultSet.init(query.data, (int)query.cols);
-	nnIndex->findNeighbors(resultSet,query.data,searchParams);
-
-	// TODO: optimise here
-	int* neighbors = resultSet.getNeighbors();
-	float* distances = resultSet.getDistances();
-	size_t count_nn = std::min(resultSet.size(), indices.cols);
-
-	assert (dists.cols>=count_nn);
-
-	for (size_t i=0;i<count_nn;++i) {
-		indices[0][i] = neighbors[i];
-		dists[0][i] = distances[i];
-	}
-
-	return (int)count_nn;
-}
-
-
-template<typename T>
-void Index<T>::save(std::string filename)
-{
-	FILE* fout = fopen(filename.c_str(), "wb");
-	if (fout==NULL) {
-		throw FLANNException("Cannot open file");
-	}
-	save_header(fout, *nnIndex);
-	nnIndex->saveIndex(fout);
-	fclose(fout);
-}
-
-
-template<typename T>
-int Index<T>::size() const
-{
-	return nnIndex->size();
-}
-
-template<typename T>
-int Index<T>::veclen() const
-{
-	return nnIndex->veclen();
-}
-
-
-template <typename ELEM_TYPE, typename DIST_TYPE>
-int hierarchicalClustering(const Matrix<ELEM_TYPE>& features, Matrix<DIST_TYPE>& centers, const KMeansIndexParams& params)
-{
-    KMeansIndex<ELEM_TYPE, DIST_TYPE> kmeans(features, params);
-	kmeans.buildIndex();
+    KMeansIndex<Distance> kmeans(points, params, d);
+    kmeans.buildIndex();
 
     int clusterNum = kmeans.getClusterCenters(centers);
-	return clusterNum;
+    return clusterNum;
 }
 
-} // namespace cvflann
-#endif /* _OPENCV_FLANN_BASE_HPP_ */
+}
+#endif /* FLANN_BASE_HPP_ */
diff --git a/modules/flann/include/opencv2/flann/general.h b/modules/flann/include/opencv2/flann/general.h
index 880cc84b0c..87e7e2f288 100644
--- a/modules/flann/include/opencv2/flann/general.h
+++ b/modules/flann/include/opencv2/flann/general.h
@@ -28,119 +28,25 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_GENERAL_H_
-#define _OPENCV_GENERAL_H_
-
-#ifdef __cplusplus
+#ifndef OPENCV_FLANN_GENERAL_H_
+#define OPENCV_FLANN_GENERAL_H_
 
+#include "defines.h"
 #include <stdexcept>
 #include <cassert>
-#include "opencv2/flann/object_factory.h"
-#include "opencv2/flann/logger.h"
 
-namespace cvflann {
-
-#undef ARRAY_LEN
-#define ARRAY_LEN(a) (sizeof(a)/sizeof(a[0]))
-
-/* Nearest neighbour index algorithms */
-enum flann_algorithm_t {
-	FLANN_INDEX_LINEAR = 0,
-	FLANN_INDEX_KDTREE = 1,
-	FLANN_INDEX_KMEANS = 2,
-	FLANN_INDEX_COMPOSITE = 3,
-	FLANN_INDEX_SAVED = 254,
-	FLANN_INDEX_AUTOTUNED = 255
-};
-
-enum flann_centers_init_t {
-	FLANN_CENTERS_RANDOM = 0,
-	FLANN_CENTERS_GONZALES = 1,
-	FLANN_CENTERS_KMEANSPP = 2
-};
-
-
-enum flann_distance_t {
-	FLANN_DIST_EUCLIDEAN = 1,
-	FLANN_DIST_L2 = 1,
-	FLANN_DIST_MANHATTAN = 2,
-	FLANN_DIST_L1 = 2,
-	FLANN_DIST_MINKOWSKI = 3,
-	FLANN_DIST_MAX       = 4,
-	FLANN_DIST_HIST_INTERSECT = 5,
-	FLANN_DIST_HELLINGER = 6,
-	FLANN_DIST_CHI_SQUARE = 7,
-	FLANN_DIST_CS         = 7,
-	FLANN_DIST_KULLBACK_LEIBLER        = 8,
-	FLANN_DIST_KL        = 8
-};
-
-enum flann_datatype_t {
-	FLANN_INT8 = 0,
-	FLANN_INT16 = 1,
-	FLANN_INT32 = 2,
-	FLANN_INT64 = 3,
-	FLANN_UINT8 = 4,
-	FLANN_UINT16 = 5,
-	FLANN_UINT32 = 6,
-	FLANN_UINT64 = 7,
-	FLANN_FLOAT32 = 8,
-	FLANN_FLOAT64 = 9
-};
-
-template <typename ELEM_TYPE>
-struct DistType
+namespace cvflann
 {
-	typedef ELEM_TYPE type;
-};
 
-template <>
-struct DistType<unsigned char>
+class FLANNException : public std::runtime_error
 {
-	typedef float type;
-};
-
-template <>
-struct DistType<int>
-{
-	typedef float type;
-};
-
-
-class FLANNException : public std::runtime_error {
- public:
-   FLANNException(const char* message) : std::runtime_error(message) { }
-
-   FLANNException(const std::string& message) : std::runtime_error(message) { }
- };
-
-
-struct CV_EXPORTS IndexParams {
-protected:
-	IndexParams(flann_algorithm_t algorithm_) : algorithm(algorithm_) {};
-	
 public:
-	virtual ~IndexParams() {}
-	virtual flann_algorithm_t getIndexType() const { return algorithm; }
+    FLANNException(const char* message) : std::runtime_error(message) { }
 
-	virtual void print() const = 0;
-
-	flann_algorithm_t algorithm;
+    FLANNException(const std::string& message) : std::runtime_error(message) { }
 };
 
+}
 
-typedef ObjectFactory<IndexParams, flann_algorithm_t> ParamsFactory;
-CV_EXPORTS ParamsFactory& ParamsFactory_instance();
 
-struct CV_EXPORTS SearchParams {
-	SearchParams(int checks_ = 32) :
-		checks(checks_) {};
-
-	int checks;
-};
-
-} // namespace cvflann
-
-#endif
-
-#endif  /* _OPENCV_GENERAL_H_ */
+#endif  /* OPENCV_FLANN_GENERAL_H_ */
diff --git a/modules/flann/include/opencv2/flann/ground_truth.h b/modules/flann/include/opencv2/flann/ground_truth.h
index cb213246e5..8f1c698a22 100644
--- a/modules/flann/include/opencv2/flann/ground_truth.h
+++ b/modules/flann/include/opencv2/flann/ground_truth.h
@@ -28,39 +28,41 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_GROUND_TRUTH_H_
-#define _OPENCV_GROUND_TRUTH_H_
+#ifndef OPENCV_FLANN_GROUND_TRUTH_H_
+#define OPENCV_FLANN_GROUND_TRUTH_H_
+
+#include "dist.h"
+#include "matrix.h"
 
-#include "opencv2/flann/dist.h"
-#include "opencv2/flann/matrix.h"
 
 namespace cvflann
 {
 
-template <typename T>
-void find_nearest(const Matrix<T>& dataset, T* query, int* matches, int nn, int skip = 0)
+template <typename Distance>
+void find_nearest(const Matrix<typename Distance::ElementType>& dataset, typename Distance::ElementType* query, int* matches, int nn,
+                  int skip = 0, Distance distance = Distance())
 {
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
     int n = nn + skip;
 
-    T* query_end = query + dataset.cols;
+    int* match = new int[n];
+    DistanceType* dists = new DistanceType[n];
 
-    long* match = new long[n];
-    T* dists = new T[n];
-
-    dists[0] = (float)flann_dist(query, query_end, dataset[0]);
+    dists[0] = distance(dataset[0], query, dataset.cols);
     match[0] = 0;
     int dcnt = 1;
 
-    for (size_t i=1;i<dataset.rows;++i) {
-        T tmp = (T)flann_dist(query, query_end, dataset[i]);
+    for (size_t i=1; i<dataset.rows; ++i) {
+        DistanceType tmp = distance(dataset[i], query, dataset.cols);
 
         if (dcnt<n) {
-            match[dcnt] = (long)i;
+            match[dcnt] = i;
             dists[dcnt++] = tmp;
         }
         else if (tmp < dists[dcnt-1]) {
             dists[dcnt-1] = tmp;
-            match[dcnt-1] = (long)i;
+            match[dcnt-1] = i;
         }
 
         int j = dcnt-1;
@@ -72,7 +74,7 @@ void find_nearest(const Matrix<T>& dataset, T* query, int* matches, int nn, int
         }
     }
 
-    for (int i=0;i<nn;++i) {
+    for (int i=0; i<nn; ++i) {
         matches[i] = match[i+skip];
     }
 
@@ -81,15 +83,16 @@ void find_nearest(const Matrix<T>& dataset, T* query, int* matches, int nn, int
 }
 
 
-template <typename T>
-void compute_ground_truth(const Matrix<T>& dataset, const Matrix<T>& testset, Matrix<int>& matches, int skip=0)
+template <typename Distance>
+void compute_ground_truth(const Matrix<typename Distance::ElementType>& dataset, const Matrix<typename Distance::ElementType>& testset, Matrix<int>& matches,
+                          int skip=0, Distance d = Distance())
 {
-    for (size_t i=0;i<testset.rows;++i) {
-        find_nearest(dataset, testset[i], matches[i], (int)matches.cols, skip);
+    for (size_t i=0; i<testset.rows; ++i) {
+        find_nearest<Distance>(dataset, testset[i], matches[i], (int)matches.cols, skip, d);
     }
 }
 
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_GROUND_TRUTH_H_
+#endif //OPENCV_FLANN_GROUND_TRUTH_H_
diff --git a/modules/flann/include/opencv2/flann/hdf5.h b/modules/flann/include/opencv2/flann/hdf5.h
index 727d5a13ac..ff92434158 100644
--- a/modules/flann/include/opencv2/flann/hdf5.h
+++ b/modules/flann/include/opencv2/flann/hdf5.h
@@ -27,137 +27,207 @@
  *************************************************************************/
 
 
-#ifndef _OPENCV_HDF5_H_
-#define _OPENCV_HDF5_H_
+#ifndef OPENCV_FLANN_HDF5_H_
+#define OPENCV_FLANN_HDF5_H_
 
-#include <H5Cpp.h>
+#include <hdf5.h>
 
-#include "opencv2/flann/matrix.h"
+#include "matrix.h"
 
 
+namespace cvflann
+{
 
-#ifndef H5_NO_NAMESPACE
-    using namespace H5;
+namespace
+{
+
+template<typename T>
+hid_t get_hdf5_type()
+{
+    throw FLANNException("Unsupported type for IO operations");
+}
+
+template<>
+hid_t get_hdf5_type<char>() { return H5T_NATIVE_CHAR; }
+template<>
+hid_t get_hdf5_type<unsigned char>() { return H5T_NATIVE_UCHAR; }
+template<>
+hid_t get_hdf5_type<short int>() { return H5T_NATIVE_SHORT; }
+template<>
+hid_t get_hdf5_type<unsigned short int>() { return H5T_NATIVE_USHORT; }
+template<>
+hid_t get_hdf5_type<int>() { return H5T_NATIVE_INT; }
+template<>
+hid_t get_hdf5_type<unsigned int>() { return H5T_NATIVE_UINT; }
+template<>
+hid_t get_hdf5_type<long>() { return H5T_NATIVE_LONG; }
+template<>
+hid_t get_hdf5_type<unsigned long>() { return H5T_NATIVE_ULONG; }
+template<>
+hid_t get_hdf5_type<float>() { return H5T_NATIVE_FLOAT; }
+template<>
+hid_t get_hdf5_type<double>() { return H5T_NATIVE_DOUBLE; }
+template<>
+hid_t get_hdf5_type<long double>() { return H5T_NATIVE_LDOUBLE; }
+}
+
+
+#define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y));
+
+template<typename T>
+void save_to_file(const cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+{
+
+#if H5Eset_auto_vers == 2
+    H5Eset_auto( H5E_DEFAULT, NULL, NULL );
+#else
+    H5Eset_auto( NULL, NULL );
 #endif
 
-namespace cvflann 
-{
+    herr_t status;
+    hid_t file_id;
+    file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
+    if (file_id < 0) {
+        file_id = H5Fcreate(filename.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
+    }
+    CHECK_ERROR(file_id,"Error creating hdf5 file.");
 
+    hsize_t     dimsf[2];              // dataset dimensions
+    dimsf[0] = dataset.rows;
+    dimsf[1] = dataset.cols;
 
-namespace {
+    hid_t space_id = H5Screate_simple(2, dimsf, NULL);
+    hid_t memspace_id = H5Screate_simple(2, dimsf, NULL);
 
-template<typename T>
-PredType get_hdf5_type()
-{
-	throw FLANNException("Unsupported type for IO operations");
-}
+    hid_t dataset_id;
+#if H5Dcreate_vers == 2
+    dataset_id = H5Dcreate2(file_id, name.c_str(), get_hdf5_type<T>(), space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+#else
+    dataset_id = H5Dcreate(file_id, name.c_str(), get_hdf5_type<T>(), space_id, H5P_DEFAULT);
+#endif
 
-template<> PredType get_hdf5_type<char>() { return PredType::NATIVE_CHAR; }
-template<> PredType get_hdf5_type<unsigned char>() { return PredType::NATIVE_UCHAR; }
-template<> PredType get_hdf5_type<short int>() { return PredType::NATIVE_SHORT; }
-template<> PredType get_hdf5_type<unsigned short int>() { return PredType::NATIVE_USHORT; }
-template<> PredType get_hdf5_type<int>() { return PredType::NATIVE_INT; }
-template<> PredType get_hdf5_type<unsigned int>() { return PredType::NATIVE_UINT; }
-template<> PredType get_hdf5_type<long>() { return PredType::NATIVE_LONG; }
-template<> PredType get_hdf5_type<unsigned long>() { return PredType::NATIVE_ULONG; }
-template<> PredType get_hdf5_type<float>() { return PredType::NATIVE_FLOAT; }
-template<> PredType get_hdf5_type<double>() { return PredType::NATIVE_DOUBLE; }
-template<> PredType get_hdf5_type<long double>() { return PredType::NATIVE_LDOUBLE; }
+    if (dataset_id<0) {
+#if H5Dopen_vers == 2
+        dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
+#else
+        dataset_id = H5Dopen(file_id, name.c_str());
+#endif
+    }
+    CHECK_ERROR(dataset_id,"Error creating or opening dataset in file.");
+
+    status = H5Dwrite(dataset_id, get_hdf5_type<T>(), memspace_id, space_id, H5P_DEFAULT, dataset.data );
+    CHECK_ERROR(status, "Error writing to dataset");
+
+    H5Sclose(memspace_id);
+    H5Sclose(space_id);
+    H5Dclose(dataset_id);
+    H5Fclose(file_id);
 
 }
 
 
 template<typename T>
-void save_to_file(const cvflann::Matrix<T>& flann_dataset, const std::string& filename, const std::string& name)
+void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
 {
-	// Try block to detect exceptions raised by any of the calls inside it
-	try
-	{
-		/*
-		 * Turn off the auto-printing when failure occurs so that we can
-		 * handle the errors appropriately
-		 */
-		Exception::dontPrint();
+    herr_t status;
+    hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
+    CHECK_ERROR(file_id,"Error opening hdf5 file.");
 
-		/*
-		 * Create a new file using H5F_ACC_TRUNC access,
-		 * default file creation properties, and default file
-		 * access properties.
-		 */
-		H5File file( filename, H5F_ACC_TRUNC );
+    hid_t dataset_id;
+#if H5Dopen_vers == 2
+    dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
+#else
+    dataset_id = H5Dopen(file_id, name.c_str());
+#endif
+    CHECK_ERROR(dataset_id,"Error opening dataset in file.");
 
-		/*
-		 * Define the size of the array and create the data space for fixed
-		 * size dataset.
-		 */
-		hsize_t     dimsf[2];              // dataset dimensions
-		dimsf[0] = flann_dataset.rows;
-		dimsf[1] = flann_dataset.cols;
-		DataSpace dataspace( 2, dimsf );
+    hid_t space_id = H5Dget_space(dataset_id);
 
-		/*
-		 * Create a new dataset within the file using defined dataspace and
-		 * datatype and default dataset creation properties.
-		 */
-		DataSet dataset = file.createDataSet( name, get_hdf5_type<T>(), dataspace );
+    hsize_t dims_out[2];
+    H5Sget_simple_extent_dims(space_id, dims_out, NULL);
 
-		/*
-		 * Write the data to the dataset using default memory space, file
-		 * space, and transfer properties.
-		 */
-		dataset.write( flann_dataset.data, get_hdf5_type<T>() );
-	}  // end of try block
-	catch( H5::Exception& error )
-	{
-		error.printError();
-		throw FLANNException(error.getDetailMsg());
-	}
+    dataset = cvflann::Matrix<T>(new T[dims_out[0]*dims_out[1]], dims_out[0], dims_out[1]);
+
+    status = H5Dread(dataset_id, get_hdf5_type<T>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, dataset[0]);
+    CHECK_ERROR(status, "Error reading dataset");
+
+    H5Sclose(space_id);
+    H5Dclose(dataset_id);
+    H5Fclose(file_id);
 }
 
 
+#ifdef HAVE_MPI
+
+namespace mpi
+{
+/**
+ * Loads a the hyperslice corresponding to this processor from a hdf5 file.
+ * @param flann_dataset Dataset where the data is loaded
+ * @param filename HDF5 file name
+ * @param name Name of dataset inside file
+ */
 template<typename T>
-void load_from_file(cvflann::Matrix<T>& flann_dataset, const std::string& filename, const std::string& name)
+void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
 {
-	try
-	{
-		Exception::dontPrint();
+    MPI_Comm comm  = MPI_COMM_WORLD;
+    MPI_Info info  = MPI_INFO_NULL;
 
-		H5File file( filename, H5F_ACC_RDONLY );
-		DataSet dataset = file.openDataSet( name );
+    int mpi_size, mpi_rank;
+    MPI_Comm_size(comm, &mpi_size);
+    MPI_Comm_rank(comm, &mpi_rank);
 
-		/*
-		 * Check the type used by the dataset matches
-		 */
-		if ( !(dataset.getDataType()==get_hdf5_type<T>())) {
-			throw FLANNException("Dataset matrix type does not match the type to be read.");
-		}
+    herr_t status;
 
-		/*
-		 * Get dataspace of the dataset.
-		 */
-		DataSpace dataspace = dataset.getSpace();
+    hid_t plist_id = H5Pcreate(H5P_FILE_ACCESS);
+    H5Pset_fapl_mpio(plist_id, comm, info);
+    hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, plist_id);
+    CHECK_ERROR(file_id,"Error opening hdf5 file.");
+    H5Pclose(plist_id);
+    hid_t dataset_id;
+#if H5Dopen_vers == 2
+    dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT);
+#else
+    dataset_id = H5Dopen(file_id, name.c_str());
+#endif
+    CHECK_ERROR(dataset_id,"Error opening dataset in file.");
 
-		/*
-		 * Get the dimension size of each dimension in the dataspace and
-		 * display them.
-		 */
-		hsize_t dims_out[2];
-		dataspace.getSimpleExtentDims( dims_out, NULL);
-		
-		flann_dataset.rows = dims_out[0];
-		flann_dataset.cols = dims_out[1];
-		flann_dataset.data = new T[flann_dataset.rows*flann_dataset.cols];
+    hid_t space_id = H5Dget_space(dataset_id);
+    hsize_t dims[2];
+    H5Sget_simple_extent_dims(space_id, dims, NULL);
 
-		dataset.read( flann_dataset.data, get_hdf5_type<T>() );
-	}  // end of try block
-	catch( H5::Exception &error )
-	{
-		error.printError();
-		throw FLANNException(error.getDetailMsg());
-	}
+    hsize_t count[2];
+    hsize_t offset[2];
+
+    hsize_t item_cnt = dims[0]/mpi_size+(dims[0]%mpi_size==0 ? 0 : 1);
+    hsize_t cnt = (mpi_rank<mpi_size-1 ? item_cnt : dims[0]-item_cnt*(mpi_size-1));
+
+    count[0] = cnt;
+    count[1] = dims[1];
+    offset[0] = mpi_rank*item_cnt;
+    offset[1] = 0;
+
+    hid_t memspace_id = H5Screate_simple(2,count,NULL);
+
+    H5Sselect_hyperslab(space_id, H5S_SELECT_SET, offset, NULL, count, NULL);
+
+    dataset.rows = count[0];
+    dataset.cols = count[1];
+    dataset.data = new T[dataset.rows*dataset.cols];
+
+    plist_id = H5Pcreate(H5P_DATASET_XFER);
+    H5Pset_dxpl_mpio(plist_id, H5FD_MPIO_COLLECTIVE);
+    status = H5Dread(dataset_id, get_hdf5_type<T>(), memspace_id, space_id, plist_id, dataset.data);
+    CHECK_ERROR(status, "Error reading dataset");
+
+    H5Pclose(plist_id);
+    H5Sclose(space_id);
+    H5Sclose(memspace_id);
+    H5Dclose(dataset_id);
+    H5Fclose(file_id);
 }
+}
+#endif // HAVE_MPI
+} // namespace cvflann::mpi
 
-
-} // namespace cvflann
-
-#endif /* _OPENCV_HDF5_H_ */
+#endif /* OPENCV_FLANN_HDF5_H_ */
diff --git a/modules/flann/include/opencv2/flann/heap.h b/modules/flann/include/opencv2/flann/heap.h
index 0e05451364..dc0a6f7712 100644
--- a/modules/flann/include/opencv2/flann/heap.h
+++ b/modules/flann/include/opencv2/flann/heap.h
@@ -28,11 +28,11 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_HEAP_H_
-#define _OPENCV_HEAP_H_
-
+#ifndef OPENCV_FLANN_HEAP_H_
+#define OPENCV_FLANN_HEAP_H_
 
 #include <algorithm>
+#include <vector>
 
 namespace cvflann
 {
@@ -43,166 +43,123 @@ namespace cvflann
  * The priority queue is implemented with a heap.  A heap is a complete
  * (full) binary tree in which each parent is less than both of its
  * children, but the order of the children is unspecified.
- * Note that a heap uses 1-based indexing to allow for power-of-2
- * location of parents and children.  We ignore element 0 of Heap array.
  */
 template <typename T>
-class Heap {
+class Heap
+{
 
-	/**
-	* Storage array for the heap.
-	* Type T must be comparable.
-	*/
-	T* heap;
+    /**
+     * Storage array for the heap.
+     * Type T must be comparable.
+     */
+    std::vector<T> heap;
     int length;
 
-	/**
-	 * Number of element in the heap
-	 */
-	int count;
+    /**
+     * Number of element in the heap
+     */
+    int count;
 
 
 
 public:
-	/**
-	 * Constructor.
-	 *
-	 * Params:
-	 *     size = heap size
-	 */
+    /**
+     * Constructor.
+     *
+     * Params:
+     *     size = heap size
+     */
 
-	Heap(int size)
-	{
-        length = size+1;
-		heap = new T[length];  // heap uses 1-based indexing
-		count = 0;
-	}
+    Heap(int size)
+    {
+        length = size;
+        heap.reserve(length);
+        count = 0;
+    }
 
+    /**
+     *
+     * Returns: heap size
+     */
+    int size()
+    {
+        return count;
+    }
 
-	/**
-	 * Destructor.
-	 *
-	 */
-	~Heap()
-	{
-		delete[] heap;
-	}
+    /**
+     * Tests if the heap is empty
+     *
+     * Returns: true is heap empty, false otherwise
+     */
+    bool empty()
+    {
+        return size()==0;
+    }
 
-	/**
-	 *
-	 * Returns: heap size
-	 */
-	int size()
-	{
-		return count;
-	}
+    /**
+     * Clears the heap.
+     */
+    void clear()
+    {
+        heap.clear();
+        count = 0;
+    }
 
-	/**
-	 * Tests if the heap is empty
-	 *
-	 * Returns: true is heap empty, false otherwise
-	 */
-	bool empty()
-	{
-		return size()==0;
-	}
+    struct CompareT
+    {
+        bool operator()(const T& t_1, const T& t_2) const
+        {
+            return t_2 < t_1;
+        }
+    };
 
-	/**
-	 * Clears the heap.
-	 */
-	void clear()
-	{
-		count = 0;
-	}
+    /**
+     * Insert a new element in the heap.
+     *
+     * We select the next empty leaf node, and then keep moving any larger
+     * parents down until the right location is found to store this element.
+     *
+     * Params:
+     *     value = the new element to be inserted in the heap
+     */
+    void insert(T value)
+    {
+        /* If heap is full, then return without adding this element. */
+        if (count == length) {
+            return;
+        }
 
-
-	/**
-	 * Insert a new element in the heap.
-	 *
-	 * We select the next empty leaf node, and then keep moving any larger
-	 * parents down until the right location is found to store this element.
-	 *
-	 * Params:
-	 *     value = the new element to be inserted in the heap
-	 */
-	void insert(T value)
-	{
-		/* If heap is full, then return without adding this element. */
-		if (count == length-1) {
-			return;
-		}
-
-		int loc = ++(count);   /* Remember 1-based indexing. */
-
-		/* Keep moving parents down until a place is found for this node. */
-		int par = loc / 2;                 /* Location of parent. */
-		while (par > 0  && value < heap[par]) {
-			heap[loc] = heap[par];     /* Move parent down to loc. */
-			loc = par;
-			par = loc / 2;
-		}
-		/* Insert the element at the determined location. */
-		heap[loc] = value;
-	}
+        heap.push_back(value);
+        static CompareT compareT;
+        std::push_heap(heap.begin(), heap.end(), compareT);
+        ++count;
+    }
 
 
 
-	/**
- 	 * Returns the node of minimum value from the heap (top of the heap).
-	 *
-	 * Params:
-	 *     value = out parameter used to return the min element
-	 * Returns: false if heap empty
-	 */
-	bool popMin(T& value)
-	{
-		if (count == 0) {
- 			return false;
-		}
+    /**
+     * Returns the node of minimum value from the heap (top of the heap).
+     *
+     * Params:
+     *     value = out parameter used to return the min element
+     * Returns: false if heap empty
+     */
+    bool popMin(T& value)
+    {
+        if (count == 0) {
+            return false;
+        }
 
-		/* Switch first node with last. */
-        std::swap(heap[1],heap[count]);
-
-		count -= 1;
-		heapify(1);      /* Move new node 1 to right position. */
-
-		value = heap[count + 1];
-		return true;  /* Return old last node. */
-	}
-
-
-	/**
-	 * Reorganizes the heap (a parent is smaller than its children)
-	 * starting with a node.
-	 *
-	 * Params:
-	 *     parent = node form which to start heap reorganization.
-	 */
-	void heapify(int parent)
-	{
-		int minloc = parent;
-
-		/* Check the left child */
-		int left = 2 * parent;
-		if (left <= count && heap[left] < heap[parent]) {
-			minloc = left;
-		}
-
-		/* Check the right child */
-		int right = left + 1;
-		if (right <= count && heap[right] < heap[minloc]) {
-			minloc = right;
-		}
-
-		/* If a child was smaller, than swap parent with it and Heapify. */
-		if (minloc != parent) {
-            std::swap(heap[parent],heap[minloc]);
-			heapify(minloc);
-		}
-	}
+        value = heap[0];
+        static CompareT compareT;
+        std::pop_heap(heap.begin(), heap.end(), compareT);
+        heap.pop_back();
+        --count;
 
+        return true;  /* Return old last node. */
+    }
 };
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_HEAP_H_
+#endif //OPENCV_FLANN_HEAP_H_
diff --git a/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h b/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
new file mode 100644
index 0000000000..1ca1c10dce
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
@@ -0,0 +1,717 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+#ifndef OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_
+#define OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_
+
+#include <algorithm>
+#include <string>
+#include <map>
+#include <cassert>
+#include <limits>
+#include <cmath>
+
+#include "general.h"
+#include "nn_index.h"
+#include "dist.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "heap.h"
+#include "allocator.h"
+#include "random.h"
+#include "saving.h"
+
+
+namespace cvflann
+{
+
+struct HierarchicalClusteringIndexParams : public IndexParams
+{
+    HierarchicalClusteringIndexParams(int branching = 32,
+                                      flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM,
+                                      int trees = 4, int leaf_size = 100)
+    {
+        (*this)["algorithm"] = FLANN_INDEX_HIERARCHICAL;
+        // The branching factor used in the hierarchical clustering
+        (*this)["branching"] = branching;
+        // Algorithm used for picking the initial cluster centers
+        (*this)["centers_init"] = centers_init;
+        // number of parallel trees to build
+        (*this)["trees"] = trees;
+        // maximum leaf size
+        (*this)["leaf_size"] = leaf_size;
+    }
+};
+
+
+/**
+ * Hierarchical index
+ *
+ * Contains a tree constructed through a hierarchical clustering
+ * and other information for indexing a set of points for nearest-neighbour matching.
+ */
+template <typename Distance>
+class HierarchicalClusteringIndex : public NNIndex<Distance>
+{
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
+private:
+
+
+    typedef void (HierarchicalClusteringIndex::* centersAlgFunction)(int, int*, int, int*, int&);
+
+    /**
+     * The function used for choosing the cluster centers.
+     */
+    centersAlgFunction chooseCenters;
+
+
+
+    /**
+     * Chooses the initial centers in the k-means clustering in a random manner.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     *     indices_length = length of indices vector
+     *
+     */
+    void chooseCentersRandom(int k, int* indices, int indices_length, int* centers, int& centers_length)
+    {
+        UniqueRandom r(indices_length);
+
+        int index;
+        for (index=0; index<k; ++index) {
+            bool duplicate = true;
+            int rnd;
+            while (duplicate) {
+                duplicate = false;
+                rnd = r.next();
+                if (rnd<0) {
+                    centers_length = index;
+                    return;
+                }
+
+                centers[index] = indices[rnd];
+
+                for (int j=0; j<index; ++j) {
+                    DistanceType sq = distance(dataset[centers[index]], dataset[centers[j]], dataset.cols);
+                    if (sq<1e-16) {
+                        duplicate = true;
+                    }
+                }
+            }
+        }
+
+        centers_length = index;
+    }
+
+
+    /**
+     * Chooses the initial centers in the k-means using Gonzales' algorithm
+     * so that the centers are spaced apart from each other.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     * Returns:
+     */
+    void chooseCentersGonzales(int k, int* indices, int indices_length, int* centers, int& centers_length)
+    {
+        int n = indices_length;
+
+        int rnd = rand_int(n);
+        assert(rnd >=0 && rnd < n);
+
+        centers[0] = indices[rnd];
+
+        int index;
+        for (index=1; index<k; ++index) {
+
+            int best_index = -1;
+            DistanceType best_val = 0;
+            for (int j=0; j<n; ++j) {
+            	DistanceType dist = distance(dataset[centers[0]],dataset[indices[j]],dataset.cols);
+                for (int i=1; i<index; ++i) {
+                    DistanceType tmp_dist = distance(dataset[centers[i]],dataset[indices[j]],dataset.cols);
+                    if (tmp_dist<dist) {
+                        dist = tmp_dist;
+                    }
+                }
+                if (dist>best_val) {
+                    best_val = dist;
+                    best_index = j;
+                }
+            }
+            if (best_index!=-1) {
+                centers[index] = indices[best_index];
+            }
+            else {
+                break;
+            }
+        }
+        centers_length = index;
+    }
+
+
+    /**
+     * Chooses the initial centers in the k-means using the algorithm
+     * proposed in the KMeans++ paper:
+     * Arthur, David; Vassilvitskii, Sergei - k-means++: The Advantages of Careful Seeding
+     *
+     * Implementation of this function was converted from the one provided in Arthur's code.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     * Returns:
+     */
+    void chooseCentersKMeanspp(int k, int* indices, int indices_length, int* centers, int& centers_length)
+    {
+        int n = indices_length;
+
+        double currentPot = 0;
+        DistanceType* closestDistSq = new DistanceType[n];
+
+        // Choose one random center and set the closestDistSq values
+        int index = rand_int(n);
+        assert(index >=0 && index < n);
+        centers[0] = indices[index];
+
+        for (int i = 0; i < n; i++) {
+            closestDistSq[i] = distance(dataset[indices[i]], dataset[indices[index]], dataset.cols);
+            currentPot += closestDistSq[i];
+        }
+
+
+        const int numLocalTries = 1;
+
+        // Choose each center
+        int centerCount;
+        for (centerCount = 1; centerCount < k; centerCount++) {
+
+            // Repeat several trials
+            double bestNewPot = -1;
+            int bestNewIndex = 0;
+            for (int localTrial = 0; localTrial < numLocalTries; localTrial++) {
+
+                // Choose our center - have to be slightly careful to return a valid answer even accounting
+                // for possible rounding errors
+                double randVal = rand_double(currentPot);
+                for (index = 0; index < n-1; index++) {
+                    if (randVal <= closestDistSq[index]) break;
+                    else randVal -= closestDistSq[index];
+                }
+
+                // Compute the new potential
+                double newPot = 0;
+                for (int i = 0; i < n; i++) newPot += std::min( distance(dataset[indices[i]], dataset[indices[index]], dataset.cols), closestDistSq[i] );
+
+                // Store the best result
+                if ((bestNewPot < 0)||(newPot < bestNewPot)) {
+                    bestNewPot = newPot;
+                    bestNewIndex = index;
+                }
+            }
+
+            // Add the appropriate center
+            centers[centerCount] = indices[bestNewIndex];
+            currentPot = bestNewPot;
+            for (int i = 0; i < n; i++) closestDistSq[i] = std::min( distance(dataset[indices[i]], dataset[indices[bestNewIndex]], dataset.cols), closestDistSq[i] );
+        }
+
+        centers_length = centerCount;
+
+        delete[] closestDistSq;
+    }
+
+
+public:
+
+
+    /**
+     * Index constructor
+     *
+     * Params:
+     *          inputData = dataset with the input features
+     *          params = parameters passed to the hierarchical k-means algorithm
+     */
+    HierarchicalClusteringIndex(const Matrix<ElementType>& inputData, const IndexParams& index_params = HierarchicalClusteringIndexParams(),
+                                Distance d = Distance())
+        : dataset(inputData), params(index_params), root(NULL), indices(NULL), distance(d)
+    {
+        memoryCounter = 0;
+
+        size_ = dataset.rows;
+        veclen_ = dataset.cols;
+
+        branching_ = get_param(params,"branching",32);
+        centers_init_ = get_param(params,"centers_init", FLANN_CENTERS_RANDOM);
+        trees_ = get_param(params,"trees",4);
+        leaf_size_ = get_param(params,"leaf_size",100);
+
+        if (centers_init_==FLANN_CENTERS_RANDOM) {
+            chooseCenters = &HierarchicalClusteringIndex::chooseCentersRandom;
+        }
+        else if (centers_init_==FLANN_CENTERS_GONZALES) {
+            chooseCenters = &HierarchicalClusteringIndex::chooseCentersGonzales;
+        }
+        else if (centers_init_==FLANN_CENTERS_KMEANSPP) {
+            chooseCenters = &HierarchicalClusteringIndex::chooseCentersKMeanspp;
+        }
+        else {
+            throw FLANNException("Unknown algorithm for choosing initial centers.");
+        }
+
+        trees_ = get_param(params,"trees",4);
+        root = new NodePtr[trees_];
+        indices = new int*[trees_];
+    }
+
+    HierarchicalClusteringIndex(const HierarchicalClusteringIndex&);
+    HierarchicalClusteringIndex& operator=(const HierarchicalClusteringIndex&);
+
+    /**
+     * Index destructor.
+     *
+     * Release the memory used by the index.
+     */
+    virtual ~HierarchicalClusteringIndex()
+    {
+        if (indices!=NULL) {
+            delete[] indices;
+        }
+    }
+
+    /**
+     *  Returns size of index.
+     */
+    size_t size() const
+    {
+        return size_;
+    }
+
+    /**
+     * Returns the length of an index feature.
+     */
+    size_t veclen() const
+    {
+        return veclen_;
+    }
+
+
+    /**
+     * Computes the inde memory usage
+     * Returns: memory used by the index
+     */
+    int usedMemory() const
+    {
+        return pool.usedMemory+pool.wastedMemory+memoryCounter;
+    }
+
+    /**
+     * Builds the index
+     */
+    void buildIndex()
+    {
+        if (branching_<2) {
+            throw FLANNException("Branching factor must be at least 2");
+        }
+        for (int i=0; i<trees_; ++i) {
+            indices[i] = new int[size_];
+            for (size_t j=0; j<size_; ++j) {
+                indices[i][j] = j;
+            }
+            root[i] = pool.allocate<Node>();
+            computeClustering(root[i], indices[i], size_, branching_,0);
+        }
+    }
+
+
+    flann_algorithm_t getType() const
+    {
+        return FLANN_INDEX_HIERARCHICAL;
+    }
+
+
+    void saveIndex(FILE* stream)
+    {
+        save_value(stream, branching_);
+        save_value(stream, trees_);
+        save_value(stream, centers_init_);
+        save_value(stream, leaf_size_);
+        save_value(stream, memoryCounter);
+        for (int i=0; i<trees_; ++i) {
+            save_value(stream, *indices[i], size_);
+            save_tree(stream, root[i], i);
+        }
+
+    }
+
+
+    void loadIndex(FILE* stream)
+    {
+        load_value(stream, branching_);
+        load_value(stream, trees_);
+        load_value(stream, centers_init_);
+        load_value(stream, leaf_size_);
+        load_value(stream, memoryCounter);
+        indices = new int*[trees_];
+        root = new NodePtr[trees_];
+        for (int i=0; i<trees_; ++i) {
+            indices[i] = new int[size_];
+            load_value(stream, *indices[i], size_);
+            load_tree(stream, root[i], i);
+        }
+
+        params["algorithm"] = getType();
+        params["branching"] = branching_;
+        params["trees"] = trees_;
+        params["centers_init"] = centers_init_;
+        params["leaf_size"] = leaf_size_;
+    }
+
+
+    /**
+     * Find set of nearest neighbors to vec. Their indices are stored inside
+     * the result object.
+     *
+     * Params:
+     *     result = the result object in which the indices of the nearest-neighbors are stored
+     *     vec = the vector for which to search the nearest neighbors
+     *     searchParams = parameters that influence the search algorithm (checks)
+     */
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+    {
+
+        int maxChecks = get_param(searchParams,"checks",32);
+
+        // Priority queue storing intermediate branches in the best-bin-first search
+        Heap<BranchSt>* heap = new Heap<BranchSt>(size_);
+
+        std::vector<bool> checked(size_,false);
+        int checks = 0;
+        for (int i=0; i<trees_; ++i) {
+            findNN(root[i], result, vec, checks, maxChecks, heap, checked);
+        }
+
+        BranchSt branch;
+        while (heap->popMin(branch) && (checks<maxChecks || !result.full())) {
+            NodePtr node = branch.node;
+            findNN(node, result, vec, checks, maxChecks, heap, checked);
+        }
+        assert(result.full());
+
+        delete heap;
+
+    }
+
+    IndexParams getParameters() const
+    {
+        return params;
+    }
+
+
+private:
+
+    /**
+     * Struture representing a node in the hierarchical k-means tree.
+     */
+    struct Node
+    {
+        /**
+         * The cluster center index
+         */
+        int pivot;
+        /**
+         * The cluster size (number of points in the cluster)
+         */
+        int size;
+        /**
+         * Child nodes (only for non-terminal nodes)
+         */
+        Node** childs;
+        /**
+         * Node points (only for terminal nodes)
+         */
+        int* indices;
+        /**
+         * Level
+         */
+        int level;
+    };
+    typedef Node* NodePtr;
+
+
+
+    /**
+     * Alias definition for a nicer syntax.
+     */
+    typedef BranchStruct<NodePtr, DistanceType> BranchSt;
+
+
+
+    void save_tree(FILE* stream, NodePtr node, int num)
+    {
+        save_value(stream, *node);
+        if (node->childs==NULL) {
+            int indices_offset = node->indices - indices[num];
+            save_value(stream, indices_offset);
+        }
+        else {
+            for(int i=0; i<branching_; ++i) {
+                save_tree(stream, node->childs[i], num);
+            }
+        }
+    }
+
+
+    void load_tree(FILE* stream, NodePtr& node, int num)
+    {
+        node = pool.allocate<Node>();
+        load_value(stream, *node);
+        if (node->childs==NULL) {
+            int indices_offset;
+            load_value(stream, indices_offset);
+            node->indices = indices[num] + indices_offset;
+        }
+        else {
+            node->childs = pool.allocate<NodePtr>(branching_);
+            for(int i=0; i<branching_; ++i) {
+                load_tree(stream, node->childs[i], num);
+            }
+        }
+    }
+
+
+
+
+    void computeLabels(int* indices, int indices_length,  int* centers, int centers_length, int* labels, DistanceType& cost)
+    {
+        cost = 0;
+        for (int i=0; i<indices_length; ++i) {
+            ElementType* point = dataset[indices[i]];
+            DistanceType dist = distance(point, dataset[centers[0]], veclen_);
+            labels[i] = 0;
+            for (int j=1; j<centers_length; ++j) {
+                DistanceType new_dist = distance(point, dataset[centers[j]], veclen_);
+                if (dist>new_dist) {
+                    labels[i] = j;
+                    dist = new_dist;
+                }
+            }
+            cost += dist;
+        }
+    }
+
+    /**
+     * The method responsible with actually doing the recursive hierarchical
+     * clustering
+     *
+     * Params:
+     *     node = the node to cluster
+     *     indices = indices of the points belonging to the current node
+     *     branching = the branching factor to use in the clustering
+     *
+     * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point)
+     */
+    void computeClustering(NodePtr node, int* indices, int indices_length, int branching, int level)
+    {
+        node->size = indices_length;
+        node->level = level;
+
+        if (indices_length < leaf_size_) { // leaf node
+            node->indices = indices;
+            std::sort(node->indices,node->indices+indices_length);
+            node->childs = NULL;
+            return;
+        }
+
+        std::vector<int> centers(branching);
+        std::vector<int> labels(indices_length);
+
+        int centers_length;
+        (this->*chooseCenters)(branching, indices, indices_length, &centers[0], centers_length);
+
+        if (centers_length<branching) {
+            node->indices = indices;
+            std::sort(node->indices,node->indices+indices_length);
+            node->childs = NULL;
+            return;
+        }
+
+
+        //	assign points to clusters
+        DistanceType cost;
+        computeLabels(indices, indices_length, &centers[0], centers_length, &labels[0], cost);
+
+        node->childs = pool.allocate<NodePtr>(branching);
+        int start = 0;
+        int end = start;
+        for (int i=0; i<branching; ++i) {
+            for (int j=0; j<indices_length; ++j) {
+                if (labels[j]==i) {
+                    std::swap(indices[j],indices[end]);
+                    std::swap(labels[j],labels[end]);
+                    end++;
+                }
+            }
+
+            node->childs[i] = pool.allocate<Node>();
+            node->childs[i]->pivot = centers[i];
+            node->childs[i]->indices = NULL;
+            computeClustering(node->childs[i],indices+start, end-start, branching, level+1);
+            start=end;
+        }
+    }
+
+
+
+    /**
+     * Performs one descent in the hierarchical k-means tree. The branches not
+     * visited are stored in a priority queue.
+     *
+     * Params:
+     *      node = node to explore
+     *      result = container for the k-nearest neighbors found
+     *      vec = query points
+     *      checks = how many points in the dataset have been checked so far
+     *      maxChecks = maximum dataset points to checks
+     */
+
+
+    void findNN(NodePtr node, ResultSet<DistanceType>& result, const ElementType* vec, int& checks, int maxChecks,
+                Heap<BranchSt>* heap, std::vector<bool>& checked)
+    {
+        if (node->childs==NULL) {
+            if (checks>=maxChecks) {
+                if (result.full()) return;
+            }
+            checks += node->size;
+            for (int i=0; i<node->size; ++i) {
+                int index = node->indices[i];
+                if (!checked[index]) {
+                    DistanceType dist = distance(dataset[index], vec, veclen_);
+                    result.addPoint(dist, index);
+                    checked[index] = true;
+                }
+            }
+        }
+        else {
+            DistanceType* domain_distances = new DistanceType[branching_];
+            int best_index = 0;
+            domain_distances[best_index] = distance(vec, dataset[node->childs[best_index]->pivot], veclen_);
+            for (int i=1; i<branching_; ++i) {
+                domain_distances[i] = distance(vec, dataset[node->childs[i]->pivot], veclen_);
+                if (domain_distances[i]<domain_distances[best_index]) {
+                    best_index = i;
+                }
+            }
+            for (int i=0; i<branching_; ++i) {
+                if (i!=best_index) {
+                    heap->insert(BranchSt(node->childs[i],domain_distances[i]));
+                }
+            }
+            delete[] domain_distances;
+            findNN(node->childs[best_index],result,vec, checks, maxChecks, heap, checked);
+        }
+    }
+
+private:
+
+
+    /**
+     * The dataset used by this index
+     */
+    const Matrix<ElementType> dataset;
+
+    /**
+     * Parameters used by this index
+     */
+    IndexParams params;
+
+
+    /**
+     * Number of features in the dataset.
+     */
+    size_t size_;
+
+    /**
+     * Length of each feature.
+     */
+    size_t veclen_;
+
+    /**
+     * The root node in the tree.
+     */
+    NodePtr* root;
+
+    /**
+     *  Array of indices to vectors in the dataset.
+     */
+    int** indices;
+
+
+    /**
+     * The distance
+     */
+    Distance distance;
+
+    /**
+     * Pooled memory allocator.
+     *
+     * Using a pooled memory allocator is more efficient
+     * than allocating memory directly when there is a large
+     * number small of memory allocations.
+     */
+    PooledAllocator pool;
+
+    /**
+     * Memory occupied by the index.
+     */
+    int memoryCounter;
+
+    /** index parameters */
+    int branching_;
+    int trees_;
+    flann_centers_init_t centers_init_;
+    int leaf_size_;
+
+
+};
+
+}
+
+#endif /* OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_ */
diff --git a/modules/flann/include/opencv2/flann/index_testing.h b/modules/flann/include/opencv2/flann/index_testing.h
index 476c2c2c65..c98a14b1ce 100644
--- a/modules/flann/include/opencv2/flann/index_testing.h
+++ b/modules/flann/include/opencv2/flann/index_testing.h
@@ -28,36 +28,50 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_TESTING_H_
-#define _OPENCV_TESTING_H_
+#ifndef OPENCV_FLANN_INDEX_TESTING_H_
+#define OPENCV_FLANN_INDEX_TESTING_H_
 
 #include <cstring>
 #include <cassert>
+#include <cmath>
 
-#include "opencv2/flann/matrix.h"
-#include "opencv2/flann/nn_index.h"
-#include "opencv2/flann/result_set.h"
-#include "opencv2/flann/logger.h"
-#include "opencv2/flann/timer.h"
-
+#include "matrix.h"
+#include "nn_index.h"
+#include "result_set.h"
+#include "logger.h"
+#include "timer.h"
 
 
 namespace cvflann
 {
 
-CV_EXPORTS int countCorrectMatches(int* neighbors, int* groundTruth, int n);
-
-
-template <typename ELEM_TYPE>
-float computeDistanceRaport(const Matrix<ELEM_TYPE>& inputData, ELEM_TYPE* target, int* neighbors, int* groundTruth, int veclen, int n)
+inline int countCorrectMatches(int* neighbors, int* groundTruth, int n)
 {
-	ELEM_TYPE* target_end = target + veclen;
-    float ret = 0;
-    for (int i=0;i<n;++i) {
-        float den = (float)flann_dist(target,target_end, inputData[groundTruth[i]]);
-        float num = (float)flann_dist(target,target_end, inputData[neighbors[i]]);
+    int count = 0;
+    for (int i=0; i<n; ++i) {
+        for (int k=0; k<n; ++k) {
+            if (neighbors[i]==groundTruth[k]) {
+                count++;
+                break;
+            }
+        }
+    }
+    return count;
+}
 
-        if (den==0 && num==0) {
+
+template <typename Distance>
+typename Distance::ResultType computeDistanceRaport(const Matrix<typename Distance::ElementType>& inputData, typename Distance::ElementType* target,
+                                                    int* neighbors, int* groundTruth, int veclen, int n, const Distance& distance)
+{
+    typedef typename Distance::ResultType DistanceType;
+
+    DistanceType ret = 0;
+    for (int i=0; i<n; ++i) {
+        DistanceType den = distance(inputData[groundTruth[i]], target, veclen);
+        DistanceType num = distance(inputData[neighbors[i]], target, veclen);
+
+        if ((den==0)&&(num==0)) {
             ret += 1;
         }
         else {
@@ -68,20 +82,28 @@ float computeDistanceRaport(const Matrix<ELEM_TYPE>& inputData, ELEM_TYPE* targe
     return ret;
 }
 
-template <typename ELEM_TYPE>
-float search_with_ground_truth(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& matches, int nn, int checks, float& time, float& dist, int skipMatches)
+template <typename Distance>
+float search_with_ground_truth(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
+                               const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches, int nn, int checks,
+                               float& time, typename Distance::ResultType& dist, const Distance& distance, int skipMatches)
 {
+    typedef typename Distance::ResultType DistanceType;
+
     if (matches.cols<size_t(nn)) {
-        logger().info("matches.cols=%d, nn=%d\n",matches.cols,nn);
+        Logger::info("matches.cols=%d, nn=%d\n",matches.cols,nn);
 
         throw FLANNException("Ground truth is not computed for as many neighbors as requested");
     }
 
-    KNNResultSet<ELEM_TYPE> resultSet(nn+skipMatches);
+    KNNResultSet<DistanceType> resultSet(nn+skipMatches);
     SearchParams searchParams(checks);
 
+    int* indices = new int[nn+skipMatches];
+    DistanceType* dists = new DistanceType[nn+skipMatches];
+    int* neighbors = indices + skipMatches;
+
     int correct = 0;
-    float distR = 0;
+    DistanceType distR = 0;
     StartStopTimer t;
     int repeats = 0;
     while (t.value<0.2) {
@@ -90,65 +112,69 @@ float search_with_ground_truth(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE
         correct = 0;
         distR = 0;
         for (size_t i = 0; i < testData.rows; i++) {
-            ELEM_TYPE* target = testData[i];
-            resultSet.init(target, (int)testData.cols);
-            index.findNeighbors(resultSet,target, searchParams);
-            int* neighbors = resultSet.getNeighbors();
-            neighbors = neighbors+skipMatches;
+            resultSet.init(indices, dists);
+            index.findNeighbors(resultSet, testData[i], searchParams);
 
             correct += countCorrectMatches(neighbors,matches[i], nn);
-            distR += computeDistanceRaport(inputData, target,neighbors,matches[i], (int)testData.cols, nn);
+            distR += computeDistanceRaport<Distance>(inputData, testData[i], neighbors, matches[i], testData.cols, nn, distance);
         }
         t.stop();
     }
-    time = (float)(t.value/repeats);
+    time = float(t.value/repeats);
 
+    delete[] indices;
+    delete[] dists;
 
     float precicion = (float)correct/(nn*testData.rows);
 
     dist = distR/(testData.rows*nn);
 
-    logger().info("%8d %10.4g %10.5g %10.5g %10.5g\n",
-            checks, precicion, time, 1000.0 * time / testData.rows, dist);
+    Logger::info("%8d %10.4g %10.5g %10.5g %10.5g\n",
+                 checks, precicion, time, 1000.0 * time / testData.rows, dist);
 
     return precicion;
 }
 
 
-template <typename ELEM_TYPE>
-float test_index_checks(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& matches,
-            int checks, float& precision, int nn = 1, int skipMatches = 0)
+template <typename Distance>
+float test_index_checks(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
+                        const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
+                        int checks, float& precision, const Distance& distance, int nn = 1, int skipMatches = 0)
 {
-    logger().info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist\n");
-    logger().info("---------------------------------------------------------\n");
+    typedef typename Distance::ResultType DistanceType;
+
+    Logger::info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist\n");
+    Logger::info("---------------------------------------------------------\n");
 
     float time = 0;
-    float dist = 0;
-    precision = search_with_ground_truth(index, inputData, testData, matches, nn, checks, time, dist, skipMatches);
+    DistanceType dist = 0;
+    precision = search_with_ground_truth(index, inputData, testData, matches, nn, checks, time, dist, distance, skipMatches);
 
     return time;
 }
 
-template <typename ELEM_TYPE>
-float test_index_precision(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& matches,
-             float precision, int& checks, int nn = 1, int skipMatches = 0)
+template <typename Distance>
+float test_index_precision(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
+                           const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
+                           float precision, int& checks, const Distance& distance, int nn = 1, int skipMatches = 0)
 {
-	const float SEARCH_EPS = 0.001f;
+    typedef typename Distance::ResultType DistanceType;
+    const float SEARCH_EPS = 0.001f;
 
-    logger().info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist\n");
-    logger().info("---------------------------------------------------------\n");
+    Logger::info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist\n");
+    Logger::info("---------------------------------------------------------\n");
 
     int c2 = 1;
     float p2;
     int c1 = 1;
     float p1;
     float time;
-    float dist;
+    DistanceType dist;
 
-    p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches);
+    p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches);
 
     if (p2>precision) {
-        logger().info("Got as close as I can\n");
+        Logger::info("Got as close as I can\n");
         checks = c2;
         return time;
     }
@@ -157,18 +183,18 @@ float test_index_precision(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& i
         c1 = c2;
         p1 = p2;
         c2 *=2;
-        p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches);
+        p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches);
     }
 
     int cx;
     float realPrecision;
     if (fabs(p2-precision)>SEARCH_EPS) {
-        logger().info("Start linear estimation\n");
+        Logger::info("Start linear estimation\n");
         // after we got to values in the vecinity of the desired precision
         // use linear approximation get a better estimation
 
         cx = (c1+c2)/2;
-        realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches);
+        realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches);
         while (fabs(realPrecision-precision)>SEARCH_EPS) {
 
             if (realPrecision<precision) {
@@ -179,17 +205,18 @@ float test_index_precision(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& i
             }
             cx = (c1+c2)/2;
             if (cx==c1) {
-                logger().info("Got as close as I can\n");
+                Logger::info("Got as close as I can\n");
                 break;
             }
-            realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches);
+            realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches);
         }
 
         c2 = cx;
         p2 = realPrecision;
 
-    } else {
-        logger().info("No need for linear estimation\n");
+    }
+    else {
+        Logger::info("No need for linear estimation\n");
         cx = c2;
         realPrecision = p2;
     }
@@ -199,11 +226,14 @@ float test_index_precision(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& i
 }
 
 
-template <typename ELEM_TYPE>
-float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& matches,
-                    float* precisions, int precisions_length, int nn = 1, int skipMatches = 0, float maxTime = 0)
+template <typename Distance>
+void test_index_precisions(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
+                           const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
+                           float* precisions, int precisions_length, const Distance& distance, int nn = 1, int skipMatches = 0, float maxTime = 0)
 {
-	const float SEARCH_EPS = 0.001;
+    typedef typename Distance::ResultType DistanceType;
+
+    const float SEARCH_EPS = 0.001;
 
     // make sure precisions array is sorted
     std::sort(precisions, precisions+precisions_length);
@@ -211,8 +241,8 @@ float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>&
     int pindex = 0;
     float precision = precisions[pindex];
 
-    logger().info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist");
-    logger().info("---------------------------------------------------------");
+    Logger::info("  Nodes  Precision(%)   Time(s)   Time/vec(ms)  Mean dist\n");
+    Logger::info("---------------------------------------------------------\n");
 
     int c2 = 1;
     float p2;
@@ -221,9 +251,9 @@ float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>&
     float p1;
 
     float time;
-    float dist;
+    DistanceType dist;
 
-    p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches);
+    p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches);
 
     // if precision for 1 run down the tree is already
     // better then some of the requested precisions, then
@@ -233,30 +263,30 @@ float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>&
     }
 
     if (pindex==precisions_length) {
-        logger().info("Got as close as I can\n");
-        return time;
+        Logger::info("Got as close as I can\n");
+        return;
     }
 
-    for (int i=pindex;i<precisions_length;++i) {
+    for (int i=pindex; i<precisions_length; ++i) {
 
         precision = precisions[i];
         while (p2<precision) {
             c1 = c2;
             p1 = p2;
             c2 *=2;
-            p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches);
-            if (maxTime> 0 && time > maxTime && p2<precision) return time;
+            p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches);
+            if ((maxTime> 0)&&(time > maxTime)&&(p2<precision)) return;
         }
 
         int cx;
         float realPrecision;
         if (fabs(p2-precision)>SEARCH_EPS) {
-            logger().info("Start linear estimation\n");
+            Logger::info("Start linear estimation\n");
             // after we got to values in the vecinity of the desired precision
             // use linear approximation get a better estimation
 
             cx = (c1+c2)/2;
-            realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches);
+            realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches);
             while (fabs(realPrecision-precision)>SEARCH_EPS) {
 
                 if (realPrecision<precision) {
@@ -267,25 +297,25 @@ float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>&
                 }
                 cx = (c1+c2)/2;
                 if (cx==c1) {
-                    logger().info("Got as close as I can\n");
+                    Logger::info("Got as close as I can\n");
                     break;
                 }
-                realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches);
+                realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches);
             }
 
             c2 = cx;
             p2 = realPrecision;
 
-        } else {
-            logger().info("No need for linear estimation\n");
+        }
+        else {
+            Logger::info("No need for linear estimation\n");
             cx = c2;
             realPrecision = p2;
         }
 
     }
-    return time;
 }
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_TESTING_H_
+#endif //OPENCV_FLANN_INDEX_TESTING_H_
diff --git a/modules/flann/include/opencv2/flann/kdtree_index.h b/modules/flann/include/opencv2/flann/kdtree_index.h
index 7344165e0d..dc0971c9ef 100644
--- a/modules/flann/include/opencv2/flann/kdtree_index.h
+++ b/modules/flann/include/opencv2/flann/kdtree_index.h
@@ -28,38 +28,35 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_KDTREE_H_
-#define _OPENCV_KDTREE_H_
+#ifndef OPENCV_FLANN_KDTREE_INDEX_H_
+#define OPENCV_FLANN_KDTREE_INDEX_H_
 
 #include <algorithm>
 #include <map>
 #include <cassert>
 #include <cstring>
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
-#include "opencv2/flann/matrix.h"
-#include "opencv2/flann/result_set.h"
-#include "opencv2/flann/heap.h"
-#include "opencv2/flann/allocator.h"
-#include "opencv2/flann/random.h"
-#include "opencv2/flann/saving.h"
+#include "general.h"
+#include "nn_index.h"
+#include "dynamic_bitset.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "heap.h"
+#include "allocator.h"
+#include "random.h"
+#include "saving.h"
 
 
 namespace cvflann
 {
 
-struct CV_EXPORTS KDTreeIndexParams : public IndexParams {
-	KDTreeIndexParams(int trees_ = 4) : IndexParams(FLANN_INDEX_KDTREE), trees(trees_) {};
-
-	int trees;                 // number of randomized trees to use (for kdtree)
-
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-		logger().info("Trees: %d\n", trees);
-	}
-
+struct KDTreeIndexParams : public IndexParams
+{
+    KDTreeIndexParams(int trees = 4)
+    {
+        (*this)["algorithm"] = FLANN_INDEX_KDTREE;
+        (*this)["trees"] = trees;
+    }
 };
 
 
@@ -69,223 +66,126 @@ struct CV_EXPORTS KDTreeIndexParams : public IndexParams {
  * Contains the k-d trees and other information for indexing a set of points
  * for nearest-neighbor matching.
  */
-template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
-class KDTreeIndex : public NNIndex<ELEM_TYPE>
+template <typename Distance>
+class KDTreeIndex : public NNIndex<Distance>
 {
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
 
-	enum {
-		/**
-		 * To improve efficiency, only SAMPLE_MEAN random values are used to
-		 * compute the mean and variance at each level when building a tree.
-		 * A value of 100 seems to perform as well as using all values.
-		 */
-		SAMPLE_MEAN = 100,
-		/**
-		 * Top random dimensions to consider
-		 *
-		 * When creating random trees, the dimension on which to subdivide is
-		 * selected at random from among the top RAND_DIM dimensions with the
-		 * highest variance.  A value of 5 works well.
-		 */
-		RAND_DIM=5
-	};
-
-
-	/**
-	 * Number of randomized trees that are used
-	 */
-	int numTrees;
-
-	/**
-	 *  Array of indices to vectors in the dataset.
-	 */
-	int* vind;
-
-
-	/**
-	 * The dataset used by this index
-	 */
-	const Matrix<ELEM_TYPE> dataset;
-
-    const IndexParams& index_params;
-
-	size_t size_;
-	size_t veclen_;
-
-
-    DIST_TYPE* mean;
-    DIST_TYPE* var;
-
-
-	/*--------------------- Internal Data Structures --------------------------*/
-
-	/**
-	 * A node of the binary k-d tree.
-	 *
-	 *  This is   All nodes that have vec[divfeat] < divval are placed in the
-	 *   child1 subtree, else child2., A leaf node is indicated if both children are NULL.
-	 */
-	struct TreeSt {
-		/**
-		 * Index of the vector feature used for subdivision.
-		 * If this is a leaf node (both children are NULL) then
-		 * this holds vector index for this leaf.
-		 */
-		int divfeat;
-		/**
-		 * The value used for subdivision.
-		 */
-		DIST_TYPE divval;
-		/**
-		 * The child nodes.
-		 */
-		TreeSt *child1, *child2;
-	};
-	typedef TreeSt* Tree;
 
     /**
-     * Array of k-d trees used to find neighbours.
+     * KDTree constructor
+     *
+     * Params:
+     *          inputData = dataset with the input features
+     *          params = parameters passed to the kdtree algorithm
      */
-    Tree* trees;
-    typedef BranchStruct<Tree> BranchSt;
-    typedef BranchSt* Branch;
+    KDTreeIndex(const Matrix<ElementType>& inputData, const IndexParams& params = KDTreeIndexParams(),
+                Distance d = Distance() ) :
+        dataset_(inputData), index_params_(params), distance_(d)
+    {
+        size_ = dataset_.rows;
+        veclen_ = dataset_.cols;
 
-	/**
-	 * Pooled memory allocator.
-	 *
-	 * Using a pooled memory allocator is more efficient
-	 * than allocating memory directly when there is a large
-	 * number small of memory allocations.
-	 */
-	PooledAllocator pool;
+        trees_ = get_param(index_params_,"trees",4);
+        tree_roots_ = new NodePtr[trees_];
+
+        // Create a permutable array of indices to the input vectors.
+        vind_.resize(size_);
+        for (size_t i = 0; i < size_; ++i) {
+            vind_[i] = int(i);
+        }
+
+        mean_ = new DistanceType[veclen_];
+        var_ = new DistanceType[veclen_];
+    }
 
 
+    KDTreeIndex(const KDTreeIndex&);
+    KDTreeIndex& operator=(const KDTreeIndex&);
+
+    /**
+     * Standard destructor
+     */
+    ~KDTreeIndex()
+    {
+        if (tree_roots_!=NULL) {
+            delete[] tree_roots_;
+        }
+        delete[] mean_;
+        delete[] var_;
+    }
+
+    /**
+     * Builds the index
+     */
+    void buildIndex()
+    {
+        /* Construct the randomized trees. */
+        for (int i = 0; i < trees_; i++) {
+            /* Randomize the order of vectors to allow for unbiased sampling. */
+            std::random_shuffle(vind_.begin(), vind_.end());
+            tree_roots_[i] = divideTree(&vind_[0], int(size_) );
+        }
+    }
 
-public:
 
     flann_algorithm_t getType() const
     {
         return FLANN_INDEX_KDTREE;
     }
 
-	/**
-	 * KDTree constructor
-	 *
-	 * Params:
-	 * 		inputData = dataset with the input features
-	 * 		params = parameters passed to the kdtree algorithm
-	 */
-	KDTreeIndex(const Matrix<ELEM_TYPE>& inputData, const KDTreeIndexParams& params = KDTreeIndexParams() ) :
-		dataset(inputData), index_params(params)
-	{
-        size_ = dataset.rows;
-        veclen_ = dataset.cols;
-
-        numTrees = params.trees;
-        trees = new Tree[numTrees];
-
-		// get the parameters
-//        if (params.find("trees") != params.end()) {
-//        	numTrees = (int)params["trees"];
-//        	trees = new Tree[numTrees];
-//        }
-//        else {
-//        	numTrees = -1;
-//        	trees = NULL;
-//        }
-
-		// Create a permutable array of indices to the input vectors.
-		vind = new int[size_];
-		for (size_t i = 0; i < size_; i++) {
-			vind[i] = (int)i;
-		}
-
-        mean = new DIST_TYPE[veclen_];
-        var = new DIST_TYPE[veclen_];
-	}
-
-	/**
-	 * Standard destructor
-	 */
-	~KDTreeIndex()
-	{
-		delete[] vind;
-		if (trees!=NULL) {
-			delete[] trees;
-		}
-		delete[] mean;
-        delete[] var;
-	}
-
-
-	/**
-	 * Builds the index
-	 */
-	void buildIndex()
-	{
-		/* Construct the randomized trees. */
-		for (int i = 0; i < numTrees; i++) {
-			/* Randomize the order of vectors to allow for unbiased sampling. */
-			for (int j = (int)size_; j > 0; --j) {
-				int rnd = rand_int(j);
-                std::swap(vind[j-1], vind[rnd]);
-			}
-			trees[i] = divideTree(0, (int)size_ - 1);
-		}
-	}
-
-
 
     void saveIndex(FILE* stream)
     {
-    	save_value(stream, numTrees);
-    	for (int i=0;i<numTrees;++i) {
-    		save_tree(stream, trees[i]);
-    	}
+        save_value(stream, trees_);
+        for (int i=0; i<trees_; ++i) {
+            save_tree(stream, tree_roots_[i]);
+        }
     }
 
 
 
     void loadIndex(FILE* stream)
     {
-    	load_value(stream, numTrees);
+        load_value(stream, trees_);
+        if (tree_roots_!=NULL) {
+            delete[] tree_roots_;
+        }
+        tree_roots_ = new NodePtr[trees_];
+        for (int i=0; i<trees_; ++i) {
+            load_tree(stream,tree_roots_[i]);
+        }
 
-    	if (trees!=NULL) {
-    		delete[] trees;
-    	}
-    	trees = new Tree[numTrees];
-    	for (int i=0;i<numTrees;++i) {
-    		load_tree(stream,trees[i]);
-    	}
+        index_params_["algorithm"] = getType();
+        index_params_["trees"] = tree_roots_;
     }
 
-
     /**
-    *  Returns size of index.
-    */
+     *  Returns size of index.
+     */
     size_t size() const
     {
         return size_;
     }
 
     /**
-    * Returns the length of an index feature.
-    */
+     * Returns the length of an index feature.
+     */
     size_t veclen() const
     {
         return veclen_;
     }
 
-
-	/**
-	 * Computes the inde memory usage
-	 * Returns: memory used by the index
-	 */
-	int usedMemory() const
-	{
-		return  (int)(pool.usedMemory+pool.wastedMemory+dataset.rows*sizeof(int));   // pool memory and vind array memory
-	}
-
+    /**
+     * Computes the inde memory usage
+     * Returns: memory used by the index
+     */
+    int usedMemory() const
+    {
+        return int(pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int));  // pool memory and vind array memory
+    }
 
     /**
      * Find set of nearest neighbors to vec. Their indices are stored inside
@@ -296,326 +196,426 @@ public:
      *     vec = the vector for which to search the nearest neighbors
      *     maxCheck = the maximum number of restarts (in a best-bin-first manner)
      */
-    void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams)
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
     {
-        int maxChecks = searchParams.checks;
+        int maxChecks = get_param(searchParams,"checks", 32);
+        float epsError = 1+get_param(searchParams,"eps",0.0f);
 
-        if (maxChecks<0) {
-            getExactNeighbors(result, vec);
-        } else {
-            getNeighbors(result, vec, maxChecks);
+        if (maxChecks==FLANN_CHECKS_UNLIMITED) {
+            getExactNeighbors(result, vec, epsError);
+        }
+        else {
+            getNeighbors(result, vec, maxChecks, epsError);
         }
     }
 
-	const IndexParams* getParameters() const
-	{
-		return &index_params;
-	}
+    IndexParams getParameters() const
+    {
+        return index_params_;
+    }
 
 private:
 
-	KDTreeIndex& operator=(const KDTreeIndex&);
-	KDTreeIndex(const KDTreeIndex&);
 
-
-    void save_tree(FILE* stream, Tree tree)
+    /*--------------------- Internal Data Structures --------------------------*/
+    struct Node
     {
-    	save_value(stream, *tree);
-    	if (tree->child1!=NULL) {
-    		save_tree(stream, tree->child1);
-    	}
-    	if (tree->child2!=NULL) {
-    		save_tree(stream, tree->child2);
-    	}
+        /**
+         * Dimension used for subdivision.
+         */
+        int divfeat;
+        /**
+         * The values used for subdivision.
+         */
+        DistanceType divval;
+        /**
+         * The child nodes.
+         */
+        Node* child1, * child2;
+    };
+    typedef Node* NodePtr;
+    typedef BranchStruct<NodePtr, DistanceType> BranchSt;
+    typedef BranchSt* Branch;
+
+
+
+    void save_tree(FILE* stream, NodePtr tree)
+    {
+        save_value(stream, *tree);
+        if (tree->child1!=NULL) {
+            save_tree(stream, tree->child1);
+        }
+        if (tree->child2!=NULL) {
+            save_tree(stream, tree->child2);
+        }
     }
 
 
-    void load_tree(FILE* stream, Tree& tree)
+    void load_tree(FILE* stream, NodePtr& tree)
     {
-    	tree = pool.allocate<TreeSt>();
-    	load_value(stream, *tree);
-    	if (tree->child1!=NULL) {
-    		load_tree(stream, tree->child1);
-    	}
-    	if (tree->child2!=NULL) {
-    		load_tree(stream, tree->child2);
-    	}
+        tree = pool_.allocate<Node>();
+        load_value(stream, *tree);
+        if (tree->child1!=NULL) {
+            load_tree(stream, tree->child1);
+        }
+        if (tree->child2!=NULL) {
+            load_tree(stream, tree->child2);
+        }
     }
 
 
-	/**
-	 * Create a tree node that subdivides the list of vecs from vind[first]
-	 * to vind[last].  The routine is called recursively on each sublist.
-	 * Place a pointer to this new tree node in the location pTree.
-	 *
-	 * Params: pTree = the new node to create
-	 * 			first = index of the first vector
-	 * 			last = index of the last vector
-	 */
-	Tree divideTree(int first, int last)
-	{
-		Tree node = pool.allocate<TreeSt>(); // allocate memory
+    /**
+     * Create a tree node that subdivides the list of vecs from vind[first]
+     * to vind[last].  The routine is called recursively on each sublist.
+     * Place a pointer to this new tree node in the location pTree.
+     *
+     * Params: pTree = the new node to create
+     *                  first = index of the first vector
+     *                  last = index of the last vector
+     */
+    NodePtr divideTree(int* ind, int count)
+    {
+        NodePtr node = pool_.allocate<Node>(); // allocate memory
 
-		/* If only one exemplar remains, then make this a leaf node. */
-		if (first == last) {
-			node->child1 = node->child2 = NULL;    /* Mark as leaf node. */
-			node->divfeat = vind[first];    /* Store index of this vec. */
-		}
-		else {
-			chooseDivision(node, first, last);
-			subdivide(node, first, last);
-		}
+        /* If too few exemplars remain, then make this a leaf node. */
+        if ( count == 1) {
+            node->child1 = node->child2 = NULL;    /* Mark as leaf node. */
+            node->divfeat = *ind;    /* Store index of this vec. */
+        }
+        else {
+            int idx;
+            int cutfeat;
+            DistanceType cutval;
+            meanSplit(ind, count, idx, cutfeat, cutval);
 
-		return node;
-	}
-
-
-	/**
-	 * Choose which feature to use in order to subdivide this set of vectors.
-	 * Make a random choice among those with the highest variance, and use
-	 * its variance as the threshold value.
-	 */
-	void chooseDivision(Tree node, int first, int last)
-	{
-        memset(mean,0,veclen_*sizeof(DIST_TYPE));
-        memset(var,0,veclen_*sizeof(DIST_TYPE));
-
-		/* Compute mean values.  Only the first SAMPLE_MEAN values need to be
-			sampled to get a good estimate.
-		*/
-		int end = std::min(first + SAMPLE_MEAN, last);
-		for (int j = first; j <= end; ++j) {
-			ELEM_TYPE* v = dataset[vind[j]];
-            for (size_t k=0; k<veclen_; ++k) {
-                mean[k] += v[k];
-            }
-		}
-        for (size_t k=0; k<veclen_; ++k) {
-            mean[k] /= (end - first + 1);
+            node->divfeat = cutfeat;
+            node->divval = cutval;
+            node->child1 = divideTree(ind, idx);
+            node->child2 = divideTree(ind+idx, count-idx);
         }
 
-		/* Compute variances (no need to divide by count). */
-		for (int j = first; j <= end; ++j) {
-			ELEM_TYPE* v = dataset[vind[j]];
+        return node;
+    }
+
+
+    /**
+     * Choose which feature to use in order to subdivide this set of vectors.
+     * Make a random choice among those with the highest variance, and use
+     * its variance as the threshold value.
+     */
+    void meanSplit(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval)
+    {
+        memset(mean_,0,veclen_*sizeof(DistanceType));
+        memset(var_,0,veclen_*sizeof(DistanceType));
+
+        /* Compute mean values.  Only the first SAMPLE_MEAN values need to be
+            sampled to get a good estimate.
+         */
+        int cnt = std::min((int)SAMPLE_MEAN+1, count);
+        for (int j = 0; j < cnt; ++j) {
+            ElementType* v = dataset_[ind[j]];
             for (size_t k=0; k<veclen_; ++k) {
-                DIST_TYPE dist = v[k] - mean[k];
-                var[k] += dist * dist;
+                mean_[k] += v[k];
             }
-		}
-		/* Select one of the highest variance indices at random. */
-		node->divfeat = selectDivision(var);
-		node->divval = mean[node->divfeat];
+        }
+        for (size_t k=0; k<veclen_; ++k) {
+            mean_[k] /= cnt;
+        }
 
-	}
+        /* Compute variances (no need to divide by count). */
+        for (int j = 0; j < cnt; ++j) {
+            ElementType* v = dataset_[ind[j]];
+            for (size_t k=0; k<veclen_; ++k) {
+                DistanceType dist = v[k] - mean_[k];
+                var_[k] += dist * dist;
+            }
+        }
+        /* Select one of the highest variance indices at random. */
+        cutfeat = selectDivision(var_);
+        cutval = mean_[cutfeat];
+
+        int lim1, lim2;
+        planeSplit(ind, count, cutfeat, cutval, lim1, lim2);
+
+        if (lim1>count/2) index = lim1;
+        else if (lim2<count/2) index = lim2;
+        else index = count/2;
+
+        /* If either list is empty, it means that all remaining features
+         * are identical. Split in the middle to maintain a balanced tree.
+         */
+        if ((lim1==count)||(lim2==0)) index = count/2;
+    }
 
 
-	/**
-	 * Select the top RAND_DIM largest values from v and return the index of
-	 * one of these selected at random.
-	 */
-	int selectDivision(DIST_TYPE* v)
-	{
-		int num = 0;
-		int topind[RAND_DIM];
+    /**
+     * Select the top RAND_DIM largest values from v and return the index of
+     * one of these selected at random.
+     */
+    int selectDivision(DistanceType* v)
+    {
+        int num = 0;
+        size_t topind[RAND_DIM];
 
-		/* Create a list of the indices of the top RAND_DIM values. */
-		for (size_t i = 0; i < veclen_; ++i) {
-			if (num < RAND_DIM  ||  v[i] > v[topind[num-1]]) {
-				/* Put this element at end of topind. */
-				if (num < RAND_DIM) {
-					topind[num++] = (int)i;            /* Add to list. */
-				}
-				else {
-					topind[num-1] = (int)i;         /* Replace last element. */
-				}
-				/* Bubble end value down to right location by repeated swapping. */
-				int j = num - 1;
-				while (j > 0  &&  v[topind[j]] > v[topind[j-1]]) {
+        /* Create a list of the indices of the top RAND_DIM values. */
+        for (size_t i = 0; i < veclen_; ++i) {
+            if ((num < RAND_DIM)||(v[i] > v[topind[num-1]])) {
+                /* Put this element at end of topind. */
+                if (num < RAND_DIM) {
+                    topind[num++] = i;            /* Add to list. */
+                }
+                else {
+                    topind[num-1] = i;         /* Replace last element. */
+                }
+                /* Bubble end value down to right location by repeated swapping. */
+                int j = num - 1;
+                while (j > 0  &&  v[topind[j]] > v[topind[j-1]]) {
                     std::swap(topind[j], topind[j-1]);
-					--j;
-				}
-			}
-		}
-		/* Select a random integer in range [0,num-1], and return that index. */
-		int rnd = rand_int(num);
-		return topind[rnd];
-	}
+                    --j;
+                }
+            }
+        }
+        /* Select a random integer in range [0,num-1], and return that index. */
+        int rnd = rand_int(num);
+        return (int)topind[rnd];
+    }
 
 
-	/**
-	 *  Subdivide the list of exemplars using the feature and division
-	 *  value given in this node.  Call divideTree recursively on each list.
-	*/
-	void subdivide(Tree node, int first, int last)
-	{
-		/* Move vector indices for left subtree to front of list. */
-		int i = first;
-		int j = last;
-		while (i <= j) {
-			int ind = vind[i];
-			ELEM_TYPE val = dataset[ind][node->divfeat];
-			if (val < node->divval) {
-				++i;
-			} else {
-				/* Move to end of list by swapping vind i and j. */
-                std::swap(vind[i], vind[j]);
-				--j;
-			}
-		}
-		/* If either list is empty, it means we have hit the unlikely case
-			in which all remaining features are identical. Split in the middle
-            to maintain a balanced tree.
-		*/
-		if ( (i == first) || (i == last+1)) {
-            i = (first+last+1)/2;
-		}
+    /**
+     *  Subdivide the list of points by a plane perpendicular on axe corresponding
+     *  to the 'cutfeat' dimension at 'cutval' position.
+     *
+     *  On return:
+     *  dataset[ind[0..lim1-1]][cutfeat]<cutval
+     *  dataset[ind[lim1..lim2-1]][cutfeat]==cutval
+     *  dataset[ind[lim2..count]][cutfeat]>cutval
+     */
+    void planeSplit(int* ind, int count, int cutfeat, DistanceType cutval, int& lim1, int& lim2)
+    {
+        /* Move vector indices for left subtree to front of list. */
+        int left = 0;
+        int right = count-1;
+        for (;; ) {
+            while (left<=right && dataset_[ind[left]][cutfeat]<cutval) ++left;
+            while (left<=right && dataset_[ind[right]][cutfeat]>=cutval) --right;
+            if (left>right) break;
+            std::swap(ind[left], ind[right]); ++left; --right;
+        }
+        lim1 = left;
+        right = count-1;
+        for (;; ) {
+            while (left<=right && dataset_[ind[left]][cutfeat]<=cutval) ++left;
+            while (left<=right && dataset_[ind[right]][cutfeat]>cutval) --right;
+            if (left>right) break;
+            std::swap(ind[left], ind[right]); ++left; --right;
+        }
+        lim2 = left;
+    }
 
-		node->child1 = divideTree(first, i - 1);
-		node->child2 = divideTree(i, last);
-	}
+    /**
+     * Performs an exact nearest neighbor search. The exact search performs a full
+     * traversal of the tree.
+     */
+    void getExactNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, float epsError)
+    {
+        //		checkID -= 1;  /* Set a different unique ID for each search. */
 
-
-
-	/**
-	 * Performs an exact nearest neighbor search. The exact search performs a full
-	 * traversal of the tree.
-	 */
-	void getExactNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec)
-	{
-//		checkID -= 1;  /* Set a different unique ID for each search. */
-
-		if (numTrees > 1) {
+        if (trees_ > 1) {
             fprintf(stderr,"It doesn't make any sense to use more than one tree for exact search");
-		}
-		if (numTrees>0) {
-			searchLevelExact(result, vec, trees[0], 0.0);
-		}
-		assert(result.full());
-	}
+        }
+        if (trees_>0) {
+            searchLevelExact(result, vec, tree_roots_[0], 0.0, epsError);
+        }
+        assert(result.full());
+    }
 
-	/**
-	 * Performs the approximate nearest-neighbor search. The search is approximate
-	 * because the tree traversal is abandoned after a given number of descends in
-	 * the tree.
-	 */
-	void getNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, int maxCheck)
-	{
-		int i;
-		BranchSt branch;
+    /**
+     * Performs the approximate nearest-neighbor search. The search is approximate
+     * because the tree traversal is abandoned after a given number of descends in
+     * the tree.
+     */
+    void getNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, int maxCheck, float epsError)
+    {
+        int i;
+        BranchSt branch;
 
-		int checkCount = 0;
-		Heap<BranchSt>* heap = new Heap<BranchSt>((int)size_);
-        std::vector<bool> checked(size_,false);
+        int checkCount = 0;
+        Heap<BranchSt>* heap = new Heap<BranchSt>((int)size_);
+        DynamicBitset checked(size_);
 
-		/* Search once through each tree down to root. */
-		for (i = 0; i < numTrees; ++i) {
-			searchLevel(result, vec, trees[i], 0.0, checkCount, maxCheck, heap, checked);
-		}
+        /* Search once through each tree down to root. */
+        for (i = 0; i < trees_; ++i) {
+            searchLevel(result, vec, tree_roots_[i], 0, checkCount, maxCheck, epsError, heap, checked);
+        }
 
-		/* Keep searching other branches from heap until finished. */
-		while ( heap->popMin(branch) && (checkCount < maxCheck || !result.full() )) {
-			searchLevel(result, vec, branch.node, branch.mindistsq, checkCount, maxCheck, heap, checked);
-		}
+        /* Keep searching other branches from heap until finished. */
+        while ( heap->popMin(branch) && (checkCount < maxCheck || !result.full() )) {
+            searchLevel(result, vec, branch.node, branch.mindist, checkCount, maxCheck, epsError, heap, checked);
+        }
 
-		delete heap;
+        delete heap;
 
-		assert(result.full());
-	}
+        assert(result.full());
+    }
 
 
-	/**
-	 *  Search starting from a given node of the tree.  Based on any mismatches at
-	 *  higher levels, all exemplars below this level must have a distance of
-	 *  at least "mindistsq".
-	*/
-	void searchLevel(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, Tree node, float mindistsq, int& checkCount, int maxCheck,
-			Heap<BranchSt>* heap, std::vector<bool>& checked)
-	{
-		if (result.worstDist()<mindistsq) {
-//			printf("Ignoring branch, too far\n");
-			return;
-		}
+    /**
+     *  Search starting from a given node of the tree.  Based on any mismatches at
+     *  higher levels, all exemplars below this level must have a distance of
+     *  at least "mindistsq".
+     */
+    void searchLevel(ResultSet<DistanceType>& result_set, const ElementType* vec, NodePtr node, DistanceType mindist, int& checkCount, int maxCheck,
+                     float epsError, Heap<BranchSt>* heap, DynamicBitset& checked)
+    {
+        if (result_set.worstDist()<mindist) {
+            //			printf("Ignoring branch, too far\n");
+            return;
+        }
 
-		/* If this is a leaf node, then do check and return. */
-		if (node->child1 == NULL  &&  node->child2 == NULL) {
-
-			/* Do not check same node more than once when searching multiple trees.
-				Once a vector is checked, we set its location in vind to the
-				current checkID.
-			*/
-			if (checked[node->divfeat] == true || checkCount>=maxCheck) {
-				if (result.full()) return;
-			}
+        /* If this is a leaf node, then do check and return. */
+        if ((node->child1 == NULL)&&(node->child2 == NULL)) {
+            /*  Do not check same node more than once when searching multiple trees.
+                Once a vector is checked, we set its location in vind to the
+                current checkID.
+             */
+            int index = node->divfeat;
+            if ( checked.test(index) || ((checkCount>=maxCheck)&& result_set.full()) ) return;
+            checked.set(index);
             checkCount++;
-			checked[node->divfeat] = true;
 
-			result.addPoint(dataset[node->divfeat],node->divfeat);
-			return;
-		}
+            DistanceType dist = distance_(dataset_[index], vec, veclen_);
+            result_set.addPoint(dist,index);
 
-		/* Which child branch should be taken first? */
-		ELEM_TYPE val = vec[node->divfeat];
-		DIST_TYPE diff = val - node->divval;
-		Tree bestChild = (diff < 0) ? node->child1 : node->child2;
-		Tree otherChild = (diff < 0) ? node->child2 : node->child1;
+            return;
+        }
 
-		/* Create a branch record for the branch not taken.  Add distance
-			of this feature boundary (we don't attempt to correct for any
-			use of this feature in a parent node, which is unlikely to
-			happen and would have only a small effect).  Don't bother
-			adding more branches to heap after halfway point, as cost of
-			adding exceeds their value.
-		*/
+        /* Which child branch should be taken first? */
+        ElementType val = vec[node->divfeat];
+        DistanceType diff = val - node->divval;
+        NodePtr bestChild = (diff < 0) ? node->child1 : node->child2;
+        NodePtr otherChild = (diff < 0) ? node->child2 : node->child1;
 
-		DIST_TYPE new_distsq = (DIST_TYPE)flann_dist(&val, &val+1, &node->divval, mindistsq);
-//		if (2 * checkCount < maxCheck  ||  !result.full()) {
-		if (new_distsq < result.worstDist() ||  !result.full()) {
-			heap->insert( BranchSt::make_branch(otherChild, new_distsq) );
-		}
+        /* Create a branch record for the branch not taken.  Add distance
+            of this feature boundary (we don't attempt to correct for any
+            use of this feature in a parent node, which is unlikely to
+            happen and would have only a small effect).  Don't bother
+            adding more branches to heap after halfway point, as cost of
+            adding exceeds their value.
+         */
 
-		/* Call recursively to search next level down. */
-		searchLevel(result, vec, bestChild, mindistsq, checkCount, maxCheck, heap, checked);
-	}
+        DistanceType new_distsq = mindist + distance_.accum_dist(val, node->divval, node->divfeat);
+        //		if (2 * checkCount < maxCheck  ||  !result.full()) {
+        if ((new_distsq*epsError < result_set.worstDist())||  !result_set.full()) {
+            heap->insert( BranchSt(otherChild, new_distsq) );
+        }
 
-	/**
-	 * Performs an exact search in the tree starting from a node.
-	 */
-	void searchLevelExact(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, Tree node, float mindistsq)
-	{
-		if (mindistsq>result.worstDist()) {
-			return;
-		}
+        /* Call recursively to search next level down. */
+        searchLevel(result_set, vec, bestChild, mindist, checkCount, maxCheck, epsError, heap, checked);
+    }
 
-		/* If this is a leaf node, then do check and return. */
-		if (node->child1 == NULL  &&  node->child2 == NULL) {
+    /**
+     * Performs an exact search in the tree starting from a node.
+     */
+    void searchLevelExact(ResultSet<DistanceType>& result_set, const ElementType* vec, const NodePtr node, DistanceType mindist, const float epsError)
+    {
+        /* If this is a leaf node, then do check and return. */
+        if ((node->child1 == NULL)&&(node->child2 == NULL)) {
+            int index = node->divfeat;
+            DistanceType dist = distance_(dataset_[index], vec, veclen_);
+            result_set.addPoint(dist,index);
+            return;
+        }
 
-			/* Do not check same node more than once when searching multiple trees.
-				Once a vector is checked, we set its location in vind to the
-				current checkID.
-			*/
-//			if (vind[node->divfeat] == checkID)
-//				return;
-//			vind[node->divfeat] = checkID;
+        /* Which child branch should be taken first? */
+        ElementType val = vec[node->divfeat];
+        DistanceType diff = val - node->divval;
+        NodePtr bestChild = (diff < 0) ? node->child1 : node->child2;
+        NodePtr otherChild = (diff < 0) ? node->child2 : node->child1;
 
-			result.addPoint(dataset[node->divfeat],node->divfeat);
-			return;
-		}
+        /* Create a branch record for the branch not taken.  Add distance
+            of this feature boundary (we don't attempt to correct for any
+            use of this feature in a parent node, which is unlikely to
+            happen and would have only a small effect).  Don't bother
+            adding more branches to heap after halfway point, as cost of
+            adding exceeds their value.
+         */
 
-		/* Which child branch should be taken first? */
-		ELEM_TYPE val = vec[node->divfeat];
-		DIST_TYPE diff = val - node->divval;
-		Tree bestChild = (diff < 0) ? node->child1 : node->child2;
-		Tree otherChild = (diff < 0) ? node->child2 : node->child1;
+        DistanceType new_distsq = mindist + distance_.accum_dist(val, node->divval, node->divfeat);
+
+        /* Call recursively to search next level down. */
+        searchLevelExact(result_set, vec, bestChild, mindist, epsError);
+
+        if (new_distsq*epsError<=result_set.worstDist()) {
+            searchLevelExact(result_set, vec, otherChild, new_distsq, epsError);
+        }
+    }
 
 
-		/* Call recursively to search next level down. */
-		searchLevelExact(result, vec, bestChild, mindistsq);
-		DIST_TYPE new_distsq = (DIST_TYPE)flann_dist(&val, &val+1, &node->divval, mindistsq);
-		searchLevelExact(result, vec, otherChild, new_distsq);
-	}
+private:
 
-};   // class KDTree
+    enum
+    {
+        /**
+         * To improve efficiency, only SAMPLE_MEAN random values are used to
+         * compute the mean and variance at each level when building a tree.
+         * A value of 100 seems to perform as well as using all values.
+         */
+        SAMPLE_MEAN = 100,
+        /**
+         * Top random dimensions to consider
+         *
+         * When creating random trees, the dimension on which to subdivide is
+         * selected at random from among the top RAND_DIM dimensions with the
+         * highest variance.  A value of 5 works well.
+         */
+        RAND_DIM=5
+    };
 
-} // namespace cvflann
 
-#endif //_OPENCV_KDTREE_H_
+    /**
+     * Number of randomized trees that are used
+     */
+    int trees_;
+
+    /**
+     *  Array of indices to vectors in the dataset.
+     */
+    std::vector<int> vind_;
+
+    /**
+     * The dataset used by this index
+     */
+    const Matrix<ElementType> dataset_;
+
+    IndexParams index_params_;
+
+    size_t size_;
+    size_t veclen_;
+
+
+    DistanceType* mean_;
+    DistanceType* var_;
+
+
+    /**
+     * Array of k-d trees used to find neighbours.
+     */
+    NodePtr* tree_roots_;
+
+    /**
+     * Pooled memory allocator.
+     *
+     * Using a pooled memory allocator is more efficient
+     * than allocating memory directly when there is a large
+     * number small of memory allocations.
+     */
+    PooledAllocator pool_;
+
+    Distance distance_;
+
+
+};   // class KDTreeForest
+
+}
+
+#endif //OPENCV_FLANN_KDTREE_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/kdtree_single_index.h b/modules/flann/include/opencv2/flann/kdtree_single_index.h
new file mode 100644
index 0000000000..9436a11f83
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/kdtree_single_index.h
@@ -0,0 +1,634 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+#ifndef OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
+#define OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
+
+#include <algorithm>
+#include <map>
+#include <cassert>
+#include <cstring>
+
+#include "general.h"
+#include "nn_index.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "heap.h"
+#include "allocator.h"
+#include "random.h"
+#include "saving.h"
+
+namespace cvflann
+{
+
+struct KDTreeSingleIndexParams : public IndexParams
+{
+    KDTreeSingleIndexParams(int leaf_max_size = 10, bool reorder = true, int dim = -1)
+    {
+        (*this)["algorithm"] = FLANN_INDEX_KDTREE_SINGLE;
+        (*this)["leaf_max_size"] = leaf_max_size;
+        (*this)["reorder"] = reorder;
+        (*this)["dim"] = dim;
+    }
+};
+
+
+/**
+ * Randomized kd-tree index
+ *
+ * Contains the k-d trees and other information for indexing a set of points
+ * for nearest-neighbor matching.
+ */
+template <typename Distance>
+class KDTreeSingleIndex : public NNIndex<Distance>
+{
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
+
+    /**
+     * KDTree constructor
+     *
+     * Params:
+     *          inputData = dataset with the input features
+     *          params = parameters passed to the kdtree algorithm
+     */
+    KDTreeSingleIndex(const Matrix<ElementType>& inputData, const IndexParams& params = KDTreeSingleIndexParams(),
+                      Distance d = Distance() ) :
+        dataset_(inputData), index_params_(params), distance_(d)
+    {
+        size_ = dataset_.rows;
+        dim_ = dataset_.cols;
+        int dim_param = get_param(params,"dim",-1);
+        if (dim_param>0) dim_ = dim_param;
+        leaf_max_size_ = get_param(params,"leaf_max_size",10);
+        reorder_ = get_param(params,"reorder",true);
+
+        // Create a permutable array of indices to the input vectors.
+        vind_.resize(size_);
+        for (size_t i = 0; i < size_; i++) {
+            vind_[i] = i;
+        }
+    }
+
+    KDTreeSingleIndex(const KDTreeSingleIndex&);
+    KDTreeSingleIndex& operator=(const KDTreeSingleIndex&);
+
+    /**
+     * Standard destructor
+     */
+    ~KDTreeSingleIndex()
+    {
+        if (reorder_) delete[] data_.data;
+    }
+
+    /**
+     * Builds the index
+     */
+    void buildIndex()
+    {
+        computeBoundingBox(root_bbox_);
+        root_node_ = divideTree(0, size_, root_bbox_ );   // construct the tree
+
+        if (reorder_) {
+            delete[] data_.data;
+            data_ = cvflann::Matrix<ElementType>(new ElementType[size_*dim_], size_, dim_);
+            for (size_t i=0; i<size_; ++i) {
+                for (size_t j=0; j<dim_; ++j) {
+                    data_[i][j] = dataset_[vind_[i]][j];
+                }
+            }
+        }
+        else {
+            data_ = dataset_;
+        }
+    }
+
+    flann_algorithm_t getType() const
+    {
+        return FLANN_INDEX_KDTREE_SINGLE;
+    }
+
+
+    void saveIndex(FILE* stream)
+    {
+        save_value(stream, size_);
+        save_value(stream, dim_);
+        save_value(stream, root_bbox_);
+        save_value(stream, reorder_);
+        save_value(stream, leaf_max_size_);
+        save_value(stream, vind_);
+        if (reorder_) {
+            save_value(stream, data_);
+        }
+        save_tree(stream, root_node_);
+    }
+
+
+    void loadIndex(FILE* stream)
+    {
+        load_value(stream, size_);
+        load_value(stream, dim_);
+        load_value(stream, root_bbox_);
+        load_value(stream, reorder_);
+        load_value(stream, leaf_max_size_);
+        load_value(stream, vind_);
+        if (reorder_) {
+            load_value(stream, data_);
+        }
+        else {
+            data_ = dataset_;
+        }
+        load_tree(stream, root_node_);
+
+
+        index_params_["algorithm"] = getType();
+        index_params_["leaf_max_size"] = leaf_max_size_;
+        index_params_["reorder"] = reorder_;
+    }
+
+    /**
+     *  Returns size of index.
+     */
+    size_t size() const
+    {
+        return size_;
+    }
+
+    /**
+     * Returns the length of an index feature.
+     */
+    size_t veclen() const
+    {
+        return dim_;
+    }
+
+    /**
+     * Computes the inde memory usage
+     * Returns: memory used by the index
+     */
+    int usedMemory() const
+    {
+        return pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int);  // pool memory and vind array memory
+    }
+
+
+    /**
+     * \brief Perform k-nearest neighbor search
+     * \param[in] queries The query points for which to find the nearest neighbors
+     * \param[out] indices The indices of the nearest neighbors found
+     * \param[out] dists Distances to the nearest neighbors found
+     * \param[in] knn Number of nearest neighbors to return
+     * \param[in] params Search parameters
+     */
+    void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
+    {
+        assert(queries.cols == veclen());
+        assert(indices.rows >= queries.rows);
+        assert(dists.rows >= queries.rows);
+        assert(int(indices.cols) >= knn);
+        assert(int(dists.cols) >= knn);
+
+        KNNSimpleResultSet<DistanceType> resultSet(knn);
+        for (size_t i = 0; i < queries.rows; i++) {
+            resultSet.init(indices[i], dists[i]);
+            findNeighbors(resultSet, queries[i], params);
+        }
+    }
+
+    IndexParams getParameters() const
+    {
+        return index_params_;
+    }
+
+    /**
+     * Find set of nearest neighbors to vec. Their indices are stored inside
+     * the result object.
+     *
+     * Params:
+     *     result = the result object in which the indices of the nearest-neighbors are stored
+     *     vec = the vector for which to search the nearest neighbors
+     *     maxCheck = the maximum number of restarts (in a best-bin-first manner)
+     */
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+    {
+        float epsError = 1+get_param(searchParams,"eps",0.0f);
+
+        std::vector<DistanceType> dists(dim_,0);
+        DistanceType distsq = computeInitialDistances(vec, dists);
+        searchLevel(result, vec, root_node_, distsq, dists, epsError);
+    }
+
+private:
+
+
+    /*--------------------- Internal Data Structures --------------------------*/
+    struct Node
+    {
+    	/**
+    	 * Indices of points in leaf node
+    	 */
+    	int left, right;
+    	/**
+    	 * Dimension used for subdivision.
+    	 */
+    	int divfeat;
+    	/**
+    	 * The values used for subdivision.
+    	 */
+    	DistanceType divlow, divhigh;
+        /**
+         * The child nodes.
+         */
+        Node* child1, * child2;
+    };
+    typedef Node* NodePtr;
+
+
+    struct Interval
+    {
+        DistanceType low, high;
+    };
+
+    typedef std::vector<Interval> BoundingBox;
+
+    typedef BranchStruct<NodePtr, DistanceType> BranchSt;
+    typedef BranchSt* Branch;
+
+
+
+
+    void save_tree(FILE* stream, NodePtr tree)
+    {
+        save_value(stream, *tree);
+        if (tree->child1!=NULL) {
+            save_tree(stream, tree->child1);
+        }
+        if (tree->child2!=NULL) {
+            save_tree(stream, tree->child2);
+        }
+    }
+
+
+    void load_tree(FILE* stream, NodePtr& tree)
+    {
+        tree = pool_.allocate<Node>();
+        load_value(stream, *tree);
+        if (tree->child1!=NULL) {
+            load_tree(stream, tree->child1);
+        }
+        if (tree->child2!=NULL) {
+            load_tree(stream, tree->child2);
+        }
+    }
+
+
+    void computeBoundingBox(BoundingBox& bbox)
+    {
+        bbox.resize(dim_);
+        for (size_t i=0; i<dim_; ++i) {
+            bbox[i].low = (DistanceType)dataset_[0][i];
+            bbox[i].high = (DistanceType)dataset_[0][i];
+        }
+        for (size_t k=1; k<dataset_.rows; ++k) {
+            for (size_t i=0; i<dim_; ++i) {
+                if (dataset_[k][i]<bbox[i].low) bbox[i].low = (DistanceType)dataset_[k][i];
+                if (dataset_[k][i]>bbox[i].high) bbox[i].high = (DistanceType)dataset_[k][i];
+            }
+        }
+    }
+
+
+    /**
+     * Create a tree node that subdivides the list of vecs from vind[first]
+     * to vind[last].  The routine is called recursively on each sublist.
+     * Place a pointer to this new tree node in the location pTree.
+     *
+     * Params: pTree = the new node to create
+     *                  first = index of the first vector
+     *                  last = index of the last vector
+     */
+    NodePtr divideTree(int left, int right, BoundingBox& bbox)
+    {
+        NodePtr node = pool_.allocate<Node>(); // allocate memory
+
+        /* If too few exemplars remain, then make this a leaf node. */
+        if ( (right-left) <= leaf_max_size_) {
+            node->child1 = node->child2 = NULL;    /* Mark as leaf node. */
+            node->left = left;
+            node->right = right;
+
+            // compute bounding-box of leaf points
+            for (size_t i=0; i<dim_; ++i) {
+                bbox[i].low = (DistanceType)dataset_[vind_[left]][i];
+                bbox[i].high = (DistanceType)dataset_[vind_[left]][i];
+            }
+            for (int k=left+1; k<right; ++k) {
+                for (size_t i=0; i<dim_; ++i) {
+                    if (bbox[i].low>dataset_[vind_[k]][i]) bbox[i].low=(DistanceType)dataset_[vind_[k]][i];
+                    if (bbox[i].high<dataset_[vind_[k]][i]) bbox[i].high=(DistanceType)dataset_[vind_[k]][i];
+                }
+            }
+        }
+        else {
+            int idx;
+            int cutfeat;
+            DistanceType cutval;
+            middleSplit_(&vind_[0]+left, right-left, idx, cutfeat, cutval, bbox);
+
+            node->divfeat = cutfeat;
+
+            BoundingBox left_bbox(bbox);
+            left_bbox[cutfeat].high = cutval;
+            node->child1 = divideTree(left, left+idx, left_bbox);
+
+            BoundingBox right_bbox(bbox);
+            right_bbox[cutfeat].low = cutval;
+            node->child2 = divideTree(left+idx, right, right_bbox);
+
+            node->divlow = left_bbox[cutfeat].high;
+            node->divhigh = right_bbox[cutfeat].low;
+
+            for (size_t i=0; i<dim_; ++i) {
+                bbox[i].low = std::min(left_bbox[i].low, right_bbox[i].low);
+                bbox[i].high = std::max(left_bbox[i].high, right_bbox[i].high);
+            }
+        }
+
+        return node;
+    }
+
+    void computeMinMax(int* ind, int count, int dim, ElementType& min_elem, ElementType& max_elem)
+    {
+        min_elem = dataset_[ind[0]][dim];
+        max_elem = dataset_[ind[0]][dim];
+        for (int i=1; i<count; ++i) {
+            ElementType val = dataset_[ind[i]][dim];
+            if (val<min_elem) min_elem = val;
+            if (val>max_elem) max_elem = val;
+        }
+    }
+
+    void middleSplit(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval, const BoundingBox& bbox)
+    {
+        // find the largest span from the approximate bounding box
+        ElementType max_span = bbox[0].high-bbox[0].low;
+        cutfeat = 0;
+        cutval = (bbox[0].high+bbox[0].low)/2;
+        for (size_t i=1; i<dim_; ++i) {
+            ElementType span = bbox[i].low-bbox[i].low;
+            if (span>max_span) {
+                max_span = span;
+                cutfeat = i;
+                cutval = (bbox[i].high+bbox[i].low)/2;
+            }
+        }
+
+        // compute exact span on the found dimension
+        ElementType min_elem, max_elem;
+        computeMinMax(ind, count, cutfeat, min_elem, max_elem);
+        cutval = (min_elem+max_elem)/2;
+        max_span = max_elem - min_elem;
+
+        // check if a dimension of a largest span exists
+        size_t k = cutfeat;
+        for (size_t i=0; i<dim_; ++i) {
+            if (i==k) continue;
+            ElementType span = bbox[i].high-bbox[i].low;
+            if (span>max_span) {
+                computeMinMax(ind, count, i, min_elem, max_elem);
+                span = max_elem - min_elem;
+                if (span>max_span) {
+                    max_span = span;
+                    cutfeat = i;
+                    cutval = (min_elem+max_elem)/2;
+                }
+            }
+        }
+        int lim1, lim2;
+        planeSplit(ind, count, cutfeat, cutval, lim1, lim2);
+
+        if (lim1>count/2) index = lim1;
+        else if (lim2<count/2) index = lim2;
+        else index = count/2;
+    }
+
+
+    void middleSplit_(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval, const BoundingBox& bbox)
+    {
+        const float EPS=0.00001f;
+        DistanceType max_span = bbox[0].high-bbox[0].low;
+        for (size_t i=1; i<dim_; ++i) {
+            DistanceType span = bbox[i].high-bbox[i].low;
+            if (span>max_span) {
+                max_span = span;
+            }
+        }
+        DistanceType max_spread = -1;
+        cutfeat = 0;
+        for (size_t i=0; i<dim_; ++i) {
+            DistanceType span = bbox[i].high-bbox[i].low;
+            if (span>(DistanceType)((1-EPS)*max_span)) {
+                ElementType min_elem, max_elem;
+                computeMinMax(ind, count, cutfeat, min_elem, max_elem);
+                DistanceType spread = (DistanceType)(max_elem-min_elem);
+                if (spread>max_spread) {
+                    cutfeat = i;
+                    max_spread = spread;
+                }
+            }
+        }
+        // split in the middle
+        DistanceType split_val = (bbox[cutfeat].low+bbox[cutfeat].high)/2;
+        ElementType min_elem, max_elem;
+        computeMinMax(ind, count, cutfeat, min_elem, max_elem);
+
+        if (split_val<min_elem) cutval = (DistanceType)min_elem;
+        else if (split_val>max_elem) cutval = (DistanceType)max_elem;
+        else cutval = split_val;
+
+        int lim1, lim2;
+        planeSplit(ind, count, cutfeat, cutval, lim1, lim2);
+
+        if (lim1>count/2) index = lim1;
+        else if (lim2<count/2) index = lim2;
+        else index = count/2;
+    }
+
+
+    /**
+     *  Subdivide the list of points by a plane perpendicular on axe corresponding
+     *  to the 'cutfeat' dimension at 'cutval' position.
+     *
+     *  On return:
+     *  dataset[ind[0..lim1-1]][cutfeat]<cutval
+     *  dataset[ind[lim1..lim2-1]][cutfeat]==cutval
+     *  dataset[ind[lim2..count]][cutfeat]>cutval
+     */
+    void planeSplit(int* ind, int count, int cutfeat, DistanceType cutval, int& lim1, int& lim2)
+    {
+        /* Move vector indices for left subtree to front of list. */
+        int left = 0;
+        int right = count-1;
+        for (;; ) {
+            while (left<=right && dataset_[ind[left]][cutfeat]<cutval) ++left;
+            while (left<=right && dataset_[ind[right]][cutfeat]>=cutval) --right;
+            if (left>right) break;
+            std::swap(ind[left], ind[right]); ++left; --right;
+        }
+        /* If either list is empty, it means that all remaining features
+         * are identical. Split in the middle to maintain a balanced tree.
+         */
+        lim1 = left;
+        right = count-1;
+        for (;; ) {
+            while (left<=right && dataset_[ind[left]][cutfeat]<=cutval) ++left;
+            while (left<=right && dataset_[ind[right]][cutfeat]>cutval) --right;
+            if (left>right) break;
+            std::swap(ind[left], ind[right]); ++left; --right;
+        }
+        lim2 = left;
+    }
+
+    DistanceType computeInitialDistances(const ElementType* vec, std::vector<DistanceType>& dists)
+    {
+        DistanceType distsq = 0.0;
+
+        for (size_t i = 0; i < dim_; ++i) {
+            if (vec[i] < root_bbox_[i].low) {
+                dists[i] = distance_.accum_dist(vec[i], root_bbox_[i].low, i);
+                distsq += dists[i];
+            }
+            if (vec[i] > root_bbox_[i].high) {
+                dists[i] = distance_.accum_dist(vec[i], root_bbox_[i].high, i);
+                distsq += dists[i];
+            }
+        }
+
+        return distsq;
+    }
+
+    /**
+     * Performs an exact search in the tree starting from a node.
+     */
+    void searchLevel(ResultSet<DistanceType>& result_set, const ElementType* vec, const NodePtr node, DistanceType mindistsq,
+                     std::vector<DistanceType>& dists, const float epsError)
+    {
+        /* If this is a leaf node, then do check and return. */
+        if ((node->child1 == NULL)&&(node->child2 == NULL)) {
+            DistanceType worst_dist = result_set.worstDist();
+            for (int i=node->left; i<node->right; ++i) {
+                int index = reorder_ ? i : vind_[i];
+                DistanceType dist = distance_(vec, data_[index], dim_, worst_dist);
+                if (dist<worst_dist) {
+                    result_set.addPoint(dist,vind_[i]);
+                }
+            }
+            return;
+        }
+
+        /* Which child branch should be taken first? */
+        int idx = node->divfeat;
+        ElementType val = vec[idx];
+        DistanceType diff1 = val - node->divlow;
+        DistanceType diff2 = val - node->divhigh;
+
+        NodePtr bestChild;
+        NodePtr otherChild;
+        DistanceType cut_dist;
+        if ((diff1+diff2)<0) {
+            bestChild = node->child1;
+            otherChild = node->child2;
+            cut_dist = distance_.accum_dist(val, node->divhigh, idx);
+        }
+        else {
+            bestChild = node->child2;
+            otherChild = node->child1;
+            cut_dist = distance_.accum_dist( val, node->divlow, idx);
+        }
+
+        /* Call recursively to search next level down. */
+        searchLevel(result_set, vec, bestChild, mindistsq, dists, epsError);
+
+        DistanceType dst = dists[idx];
+        mindistsq = mindistsq + cut_dist - dst;
+        dists[idx] = cut_dist;
+        if (mindistsq*epsError<=result_set.worstDist()) {
+            searchLevel(result_set, vec, otherChild, mindistsq, dists, epsError);
+        }
+        dists[idx] = dst;
+    }
+
+private:
+
+    /**
+     * The dataset used by this index
+     */
+    const Matrix<ElementType> dataset_;
+
+    IndexParams index_params_;
+
+    int leaf_max_size_;
+    bool reorder_;
+
+
+    /**
+     *  Array of indices to vectors in the dataset.
+     */
+    std::vector<int> vind_;
+
+    Matrix<ElementType> data_;
+
+    size_t size_;
+    size_t dim_;
+
+    /**
+     * Array of k-d trees used to find neighbours.
+     */
+    NodePtr root_node_;
+
+    BoundingBox root_bbox_;
+
+    /**
+     * Pooled memory allocator.
+     *
+     * Using a pooled memory allocator is more efficient
+     * than allocating memory directly when there is a large
+     * number small of memory allocations.
+     */
+    PooledAllocator pool_;
+
+    Distance distance_;
+};   // class KDTree
+
+}
+
+#endif //OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h
index 67abba5447..624c27abe8 100644
--- a/modules/flann/include/opencv2/flann/kmeans_index.h
+++ b/modules/flann/include/opencv2/flann/kmeans_index.h
@@ -28,8 +28,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_KMEANSTREE_H_
-#define _OPENCV_KMEANSTREE_H_
+#ifndef OPENCV_FLANN_KMEANS_INDEX_H_
+#define OPENCV_FLANN_KMEANS_INDEX_H_
 
 #include <algorithm>
 #include <string>
@@ -38,41 +38,36 @@
 #include <limits>
 #include <cmath>
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
-#include "opencv2/flann/matrix.h"
-#include "opencv2/flann/result_set.h"
-#include "opencv2/flann/heap.h"
-#include "opencv2/flann/allocator.h"
-#include "opencv2/flann/random.h"
+#include "general.h"
+#include "nn_index.h"
+#include "dist.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "heap.h"
+#include "allocator.h"
+#include "random.h"
+#include "saving.h"
+#include "logger.h"
 
 
 namespace cvflann
 {
 
-struct CV_EXPORTS KMeansIndexParams : public IndexParams {
-	KMeansIndexParams(int branching_ = 32, int iterations_ = 11,
-			flann_centers_init_t centers_init_ = FLANN_CENTERS_RANDOM, float cb_index_ = 0.2 ) :
-		IndexParams(FLANN_INDEX_KMEANS),
-		branching(branching_),
-		iterations(iterations_),
-		centers_init(centers_init_),
-		cb_index(cb_index_) {};
-
-	int branching;             // branching factor (for kmeans tree)
-	int iterations;            // max iterations to perform in one kmeans clustering (kmeans tree)
-	flann_centers_init_t centers_init;          // algorithm used for picking the initial cluster centers for kmeans tree
-    float cb_index;            // cluster boundary index. Used when searching the kmeans tree
-
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-		logger().info("Branching: %d\n", branching);
-		logger().info("Iterations: %d\n", iterations);
-		logger().info("Centres initialisation: %d\n", centers_init);
-		logger().info("Cluster boundary weight: %g\n", cb_index);
-	}
-
+struct KMeansIndexParams : public IndexParams
+{
+    KMeansIndexParams(int branching = 32, int iterations = 11,
+                      flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, float cb_index = 0.2 )
+    {
+        (*this)["algorithm"] = FLANN_INDEX_KMEANS;
+        // branching factor
+        (*this)["branching"] = branching;
+        // max iterations to perform in one kmeans clustering (kmeans tree)
+        (*this)["iterations"] = iterations;
+        // algorithm used for picking the initial cluster centers for kmeans tree
+        (*this)["centers_init"] = centers_init;
+        // cluster boundary index. Used when searching the kmeans tree
+        (*this)["cb_index"] = cb_index;
+    }
 };
 
 
@@ -82,145 +77,40 @@ struct CV_EXPORTS KMeansIndexParams : public IndexParams {
  * Contains a tree constructed through a hierarchical kmeans clustering
  * and other information for indexing a set of points for nearest-neighbour matching.
  */
-template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
-class KMeansIndex : public NNIndex<ELEM_TYPE>
+template <typename Distance>
+class KMeansIndex : public NNIndex<Distance>
 {
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
 
-	/**
-	 * The branching factor used in the hierarchical k-means clustering
-	 */
-	int branching;
 
-	/**
-	 * Maximum number of iterations to use when performing k-means
-	 * clustering
-	 */
-	int max_iter;
 
-     /**
-     * Cluster border index. This is used in the tree search phase when determining
-     * the closest cluster to explore next. A zero value takes into account only
-     * the cluster centres, a value greater then zero also take into account the size
-     * of the cluster.
+    typedef void (KMeansIndex::* centersAlgFunction)(int, int*, int, int*, int&);
+
+    /**
+     * The function used for choosing the cluster centers.
      */
-    float cb_index;
-
-	/**
-	 * The dataset used by this index
-	 */
-    const Matrix<ELEM_TYPE> dataset;
-
-    const IndexParams& index_params;
-
-    /**
-    * Number of features in the dataset.
-    */
-    size_t size_;
-
-    /**
-    * Length of each feature.
-    */
-    size_t veclen_;
-
-
-	/**
-	 * Struture representing a node in the hierarchical k-means tree.
-	 */
-	struct KMeansNodeSt	{
-		/**
-		 * The cluster center.
-		 */
-		DIST_TYPE* pivot;
-		/**
-		 * The cluster radius.
-		 */
-		DIST_TYPE radius;
-		/**
-		 * The cluster mean radius.
-		 */
-		DIST_TYPE mean_radius;
-		/**
-		 * The cluster variance.
-		 */
-		DIST_TYPE variance;
-		/**
-		 * The cluster size (number of points in the cluster)
-		 */
-		int size;
-		/**
-		 * Child nodes (only for non-terminal nodes)
-		 */
-		KMeansNodeSt** childs;
-		/**
-		 * Node points (only for terminal nodes)
-		 */
-		int* indices;
-		/**
-		 * Level
-		 */
-		int level;
-	};
-    typedef KMeansNodeSt* KMeansNode;
-
-
-
-    /**
-     * Alias definition for a nicer syntax.
-     */
-    typedef BranchStruct<KMeansNode> BranchSt;
-
-
-	/**
-	 * The root node in the tree.
-	 */
-	KMeansNode root;
-
-	/**
-	 *  Array of indices to vectors in the dataset.
-	 */
-	int* indices;
-
-
-	/**
-	 * Pooled memory allocator.
-	 *
-	 * Using a pooled memory allocator is more efficient
-	 * than allocating memory directly when there is a large
-	 * number small of memory allocations.
-	 */
-	PooledAllocator pool;
-
-	/**
-	 * Memory occupied by the index.
-	 */
-	int memoryCounter;
-
-
-	typedef void (KMeansIndex::*centersAlgFunction)(int, int*, int, int*, int&);
-
-    /**
-    * The function used for choosing the cluster centers.
-    */
     centersAlgFunction chooseCenters;
 
 
 
     /**
-    * Chooses the initial centers in the k-means clustering in a random manner.
-    *
-    * Params:
-    *     k = number of centers
-    *     vecs = the dataset of points
-    *     indices = indices in the dataset
-    *     indices_length = length of indices vector
-    *
-    */
+     * Chooses the initial centers in the k-means clustering in a random manner.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     *     indices_length = length of indices vector
+     *
+     */
     void chooseCentersRandom(int k, int* indices, int indices_length, int* centers, int& centers_length)
     {
         UniqueRandom r(indices_length);
 
         int index;
-        for (index=0;index<k;++index) {
+        for (index=0; index<k; ++index) {
             bool duplicate = true;
             int rnd;
             while (duplicate) {
@@ -233,8 +123,8 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
 
                 centers[index] = indices[rnd];
 
-                for (int j=0;j<index;++j) {
-                    float sq = (float)flann_dist(dataset[centers[index]],dataset[centers[index]]+dataset.cols,dataset[centers[j]]);
+                for (int j=0; j<index; ++j) {
+                    DistanceType sq = distance_(dataset_[centers[index]], dataset_[centers[j]], dataset_.cols);
                     if (sq<1e-16) {
                         duplicate = true;
                     }
@@ -247,15 +137,15 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
 
 
     /**
-    * Chooses the initial centers in the k-means using Gonzales' algorithm
-    * so that the centers are spaced apart from each other.
-    *
-    * Params:
-    *     k = number of centers
-    *     vecs = the dataset of points
-    *     indices = indices in the dataset
-    * Returns:
-    */
+     * Chooses the initial centers in the k-means using Gonzales' algorithm
+     * so that the centers are spaced apart from each other.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     * Returns:
+     */
     void chooseCentersGonzales(int k, int* indices, int indices_length, int* centers, int& centers_length)
     {
         int n = indices_length;
@@ -269,11 +159,11 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
         for (index=1; index<k; ++index) {
 
             int best_index = -1;
-            float best_val = 0;
-            for (int j=0;j<n;++j) {
-                float dist = (float)flann_dist(dataset[centers[0]],dataset[centers[0]]+dataset.cols,dataset[indices[j]]);
-                for (int i=1;i<index;++i) {
-                        float tmp_dist = (float)flann_dist(dataset[centers[i]],dataset[centers[i]]+dataset.cols,dataset[indices[j]]);
+            DistanceType best_val = 0;
+            for (int j=0; j<n; ++j) {
+                DistanceType dist = distance_(dataset_[centers[0]],dataset_[indices[j]],dataset_.cols);
+                for (int i=1; i<index; ++i) {
+                    DistanceType tmp_dist = distance_(dataset_[centers[i]],dataset_[indices[j]],dataset_.cols);
                     if (tmp_dist<dist) {
                         dist = tmp_dist;
                     }
@@ -295,24 +185,24 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
 
 
     /**
-    * Chooses the initial centers in the k-means using the algorithm
-    * proposed in the KMeans++ paper:
-    * Arthur, David; Vassilvitskii, Sergei - k-means++: The Advantages of Careful Seeding
-    *
-    * Implementation of this function was converted from the one provided in Arthur's code.
-    *
-    * Params:
-    *     k = number of centers
-    *     vecs = the dataset of points
-    *     indices = indices in the dataset
-    * Returns:
-    */
+     * Chooses the initial centers in the k-means using the algorithm
+     * proposed in the KMeans++ paper:
+     * Arthur, David; Vassilvitskii, Sergei - k-means++: The Advantages of Careful Seeding
+     *
+     * Implementation of this function was converted from the one provided in Arthur's code.
+     *
+     * Params:
+     *     k = number of centers
+     *     vecs = the dataset of points
+     *     indices = indices in the dataset
+     * Returns:
+     */
     void chooseCentersKMeanspp(int k, int* indices, int indices_length, int* centers, int& centers_length)
     {
         int n = indices_length;
 
         double currentPot = 0;
-        double* closestDistSq = new double[n];
+        DistanceType* closestDistSq = new DistanceType[n];
 
         // Choose one random center and set the closestDistSq values
         int index = rand_int(n);
@@ -320,7 +210,7 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
         centers[0] = indices[index];
 
         for (int i = 0; i < n; i++) {
-            closestDistSq[i] = flann_dist(dataset[indices[i]], dataset[indices[i]] + dataset.cols, dataset[indices[index]]);
+            closestDistSq[i] = distance_(dataset_[indices[i]], dataset_[indices[index]], dataset_.cols);
             currentPot += closestDistSq[i];
         }
 
@@ -338,21 +228,18 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
 
                 // Choose our center - have to be slightly careful to return a valid answer even accounting
                 // for possible rounding errors
-            double randVal = rand_double(currentPot);
+                double randVal = rand_double(currentPot);
                 for (index = 0; index < n-1; index++) {
-                    if (randVal <= closestDistSq[index])
-                        break;
-                    else
-                        randVal -= closestDistSq[index];
+                    if (randVal <= closestDistSq[index]) break;
+                    else randVal -= closestDistSq[index];
                 }
 
                 // Compute the new potential
                 double newPot = 0;
-                for (int i = 0; i < n; i++)
-                    newPot += std::min( flann_dist(dataset[indices[i]], dataset[indices[i]] + dataset.cols, dataset[indices[index]]), closestDistSq[i] );
+                for (int i = 0; i < n; i++) newPot += std::min( distance_(dataset_[indices[i]], dataset_[indices[index]], dataset_.cols), closestDistSq[i] );
 
                 // Store the best result
-                if (bestNewPot < 0 || newPot < bestNewPot) {
+                if ((bestNewPot < 0)||(newPot < bestNewPot)) {
                     bestNewPot = newPot;
                     bestNewIndex = index;
                 }
@@ -361,90 +248,93 @@ class KMeansIndex : public NNIndex<ELEM_TYPE>
             // Add the appropriate center
             centers[centerCount] = indices[bestNewIndex];
             currentPot = bestNewPot;
-            for (int i = 0; i < n; i++)
-                closestDistSq[i] = std::min( flann_dist(dataset[indices[i]], dataset[indices[i]]+dataset.cols, dataset[indices[bestNewIndex]]), closestDistSq[i] );
+            for (int i = 0; i < n; i++) closestDistSq[i] = std::min( distance_(dataset_[indices[i]], dataset_[indices[bestNewIndex]], dataset_.cols), closestDistSq[i] );
         }
 
         centers_length = centerCount;
 
-    	delete[] closestDistSq;
+        delete[] closestDistSq;
     }
 
 
 
 public:
 
-
     flann_algorithm_t getType() const
     {
         return FLANN_INDEX_KMEANS;
     }
 
-	/**
-	 * Index constructor
-	 *
-	 * Params:
-	 * 		inputData = dataset with the input features
-	 * 		params = parameters passed to the hierarchical k-means algorithm
-	 */
-	KMeansIndex(const Matrix<ELEM_TYPE>& inputData, const KMeansIndexParams& params = KMeansIndexParams() )
-		: dataset(inputData), index_params(params), root(NULL), indices(NULL)
-	{
-		memoryCounter = 0;
+    /**
+     * Index constructor
+     *
+     * Params:
+     *          inputData = dataset with the input features
+     *          params = parameters passed to the hierarchical k-means algorithm
+     */
+    KMeansIndex(const Matrix<ElementType>& inputData, const IndexParams& params = KMeansIndexParams(),
+                Distance d = Distance())
+        : dataset_(inputData), index_params_(params), root_(NULL), indices_(NULL), distance_(d)
+    {
+        memoryCounter_ = 0;
 
-        size_ = dataset.rows;
-        veclen_ = dataset.cols;
+        size_ = dataset_.rows;
+        veclen_ = dataset_.cols;
 
-        branching = params.branching;
-        max_iter = params.iterations;
-        if (max_iter<0) {
-        	max_iter = (std::numeric_limits<int>::max)();
+        branching_ = get_param(params,"branching",32);
+        iterations_ = get_param(params,"iterations",11);
+        if (iterations_<0) {
+            iterations_ = (std::numeric_limits<int>::max)();
         }
-        flann_centers_init_t centersInit = params.centers_init;
+        centers_init_  = get_param(params,"centers_init",FLANN_CENTERS_RANDOM);
 
-        if (centersInit==FLANN_CENTERS_RANDOM) {
-        	chooseCenters = &KMeansIndex::chooseCentersRandom;
+        if (centers_init_==FLANN_CENTERS_RANDOM) {
+            chooseCenters = &KMeansIndex::chooseCentersRandom;
         }
-        else if (centersInit==FLANN_CENTERS_GONZALES) {
-        	chooseCenters = &KMeansIndex::chooseCentersGonzales;
+        else if (centers_init_==FLANN_CENTERS_GONZALES) {
+            chooseCenters = &KMeansIndex::chooseCentersGonzales;
         }
-        else if (centersInit==FLANN_CENTERS_KMEANSPP) {
-                	chooseCenters = &KMeansIndex::chooseCentersKMeanspp;
+        else if (centers_init_==FLANN_CENTERS_KMEANSPP) {
+            chooseCenters = &KMeansIndex::chooseCentersKMeanspp;
         }
-		else {
-			throw FLANNException("Unknown algorithm for choosing initial centers.");
-		}
-        cb_index = 0.4f;
+        else {
+            throw FLANNException("Unknown algorithm for choosing initial centers.");
+        }
+        cb_index_ = 0.4f;
 
-	}
+    }
 
 
-	/**
-	 * Index destructor.
-	 *
-	 * Release the memory used by the index.
-	 */
-	virtual ~KMeansIndex()
-	{
-		if (root != NULL) {
-			free_centers(root);
-		}
-        if (indices!=NULL) {
-		  delete[] indices;
-        }
-	}
+    KMeansIndex(const KMeansIndex&);
+    KMeansIndex& operator=(const KMeansIndex&);
+
 
     /**
-    *  Returns size of index.
-    */
-	size_t size() const
+     * Index destructor.
+     *
+     * Release the memory used by the index.
+     */
+    virtual ~KMeansIndex()
+    {
+        if (root_ != NULL) {
+            free_centers(root_);
+        }
+        if (indices_!=NULL) {
+            delete[] indices_;
+        }
+    }
+
+    /**
+     *  Returns size of index.
+     */
+    size_t size() const
     {
         return size_;
     }
 
     /**
-    * Returns the length of an index feature.
-    */
+     * Returns the length of an index feature.
+     */
     size_t veclen() const
     {
         return veclen_;
@@ -453,67 +343,73 @@ public:
 
     void set_cb_index( float index)
     {
-        cb_index = index;
+        cb_index_ = index;
     }
 
+    /**
+     * Computes the inde memory usage
+     * Returns: memory used by the index
+     */
+    int usedMemory() const
+    {
+        return pool_.usedMemory+pool_.wastedMemory+memoryCounter_;
+    }
 
-	/**
-	 * Computes the inde memory usage
-	 * Returns: memory used by the index
-	 */
-	int usedMemory() const
-	{
-		return  pool.usedMemory+pool.wastedMemory+memoryCounter;
-	}
+    /**
+     * Builds the index
+     */
+    void buildIndex()
+    {
+        if (branching_<2) {
+            throw FLANNException("Branching factor must be at least 2");
+        }
 
-	/**
-	 * Builds the index
-	 */
-	void buildIndex()
-	{
-		if (branching<2) {
-			throw FLANNException("Branching factor must be at least 2");
-		}
+        indices_ = new int[size_];
+        for (size_t i=0; i<size_; ++i) {
+            indices_[i] = int(i);
+        }
 
-		indices = new int[size_];
-		for (size_t i=0;i<size_;++i) {
-			indices[i] = (int)i;
-		}
-
-		root = pool.allocate<KMeansNodeSt>();
-		computeNodeStatistics(root, indices, (int)size_);
-		computeClustering(root, indices, (int)size_, branching,0);
-	}
+        root_ = pool_.allocate<KMeansNode>();
+        computeNodeStatistics(root_, indices_, (int)size_);
+        computeClustering(root_, indices_, (int)size_, branching_,0);
+    }
 
 
     void saveIndex(FILE* stream)
     {
-    	save_value(stream, branching);
-    	save_value(stream, max_iter);
-    	save_value(stream, memoryCounter);
-    	save_value(stream, cb_index);
-    	save_value(stream, *indices, (int)size_);
+        save_value(stream, branching_);
+        save_value(stream, iterations_);
+        save_value(stream, memoryCounter_);
+        save_value(stream, cb_index_);
+        save_value(stream, *indices_, (int)size_);
 
-   		save_tree(stream, root);
+        save_tree(stream, root_);
     }
 
 
     void loadIndex(FILE* stream)
     {
-    	load_value(stream, branching);
-    	load_value(stream, max_iter);
-    	load_value(stream, memoryCounter);
-    	load_value(stream, cb_index);
-    	if (indices!=NULL) {
-    		delete[] indices;
-    	}
-		indices = new int[size_];
-    	load_value(stream, *indices, (int)size_);
+        load_value(stream, branching_);
+        load_value(stream, iterations_);
+        load_value(stream, memoryCounter_);
+        load_value(stream, cb_index_);
+        if (indices_!=NULL) {
+            delete[] indices_;
+        }
+        indices_ = new int[size_];
+        load_value(stream, *indices_, size_);
+
+        if (root_!=NULL) {
+            free_centers(root_);
+        }
+        load_tree(stream, root_);
+
+        index_params_["algorithm"] = getType();
+        index_params_["branching"] = branching_;
+        index_params_["iterations"] = iterations_;
+        index_params_["centers_init"] = centers_init_;
+        index_params_["cb_index"] = cb_index_;
 
-    	if (root!=NULL) {
-    		free_centers(root);
-    	}
-   		load_tree(stream, root);
     }
 
 
@@ -526,25 +422,24 @@ public:
      *     vec = the vector for which to search the nearest neighbors
      *     searchParams = parameters that influence the search algorithm (checks, cb_index)
      */
-    void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams)
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
     {
 
-        int maxChecks = searchParams.checks;
+        int maxChecks = get_param(searchParams,"checks",32);
 
-        if (maxChecks<0) {
-            findExactNN(root, result, vec);
+        if (maxChecks==FLANN_CHECKS_UNLIMITED) {
+            findExactNN(root_, result, vec);
         }
         else {
-             // Priority queue storing intermediate branches in the best-bin-first search
+            // Priority queue storing intermediate branches in the best-bin-first search
             Heap<BranchSt>* heap = new Heap<BranchSt>((int)size_);
 
             int checks = 0;
-
-            findNN(root, result, vec, checks, maxChecks, heap);
+            findNN(root_, result, vec, checks, maxChecks, heap);
 
             BranchSt branch;
             while (heap->popMin(branch) && (checks<maxChecks || !result.full())) {
-                KMeansNode node = branch.node;
+                KMeansNodePtr node = branch.node;
                 findNN(node, result, vec, checks, maxChecks, heap);
             }
             assert(result.full());
@@ -554,7 +449,6 @@ public:
 
     }
 
-
     /**
      * Clustering function that takes a cut in the hierarchical k-means
      * tree and return the clusters centers of that clustering.
@@ -562,332 +456,377 @@ public:
      *     numClusters = number of clusters to have in the clustering computed
      * Returns: number of cluster centers
      */
-    int getClusterCenters(Matrix<DIST_TYPE>& centers)
+    int getClusterCenters(Matrix<DistanceType>& centers)
     {
         int numClusters = centers.rows;
         if (numClusters<1) {
             throw FLANNException("Number of clusters must be at least 1");
         }
 
-        float variance;
-        KMeansNode* clusters = new KMeansNode[numClusters];
+        DistanceType variance;
+        KMeansNodePtr* clusters = new KMeansNodePtr[numClusters];
 
-        int clusterCount = getMinVarianceClusters(root, clusters, numClusters, variance);
+        int clusterCount = getMinVarianceClusters(root_, clusters, numClusters, variance);
 
-//         logger().info("Clusters requested: %d, returning %d\n",numClusters, clusterCount);
+        Logger::info("Clusters requested: %d, returning %d\n",numClusters, clusterCount);
 
-
-        for (int i=0;i<clusterCount;++i) {
-            DIST_TYPE* center = clusters[i]->pivot;
-            for (size_t j=0;j<veclen_;++j) {
+        for (int i=0; i<clusterCount; ++i) {
+            DistanceType* center = clusters[i]->pivot;
+            for (size_t j=0; j<veclen_; ++j) {
                 centers[i][j] = center[j];
             }
         }
-		delete[] clusters;
+        delete[] clusters;
 
         return clusterCount;
     }
 
-	const IndexParams* getParameters() const
-	{
-		return &index_params;
-	}
-
-
-private:
-
-	KMeansIndex& operator=(const KMeansIndex&);
-	KMeansIndex(const KMeansIndex&);
-
-    void save_tree(FILE* stream, KMeansNode node)
+    IndexParams getParameters() const
     {
-    	save_value(stream, *node);
-    	save_value(stream, *(node->pivot), (int)veclen_);
-    	if (node->childs==NULL) {
-    		int indices_offset = (int)(node->indices - indices);
-    		save_value(stream, indices_offset);
-    	}
-    	else {
-    		for(int i=0; i<branching; ++i) {
-    			save_tree(stream, node->childs[i]);
-    		}
-    	}
+        return index_params_;
     }
 
 
-    void load_tree(FILE* stream, KMeansNode& node)
+private:
+    /**
+     * Struture representing a node in the hierarchical k-means tree.
+     */
+    struct KMeansNode
     {
-    	node = pool.allocate<KMeansNodeSt>();
-    	load_value(stream, *node);
-    	node->pivot = new DIST_TYPE[veclen_];
-    	load_value(stream, *(node->pivot), (int)veclen_);
-    	if (node->childs==NULL) {
-    		int indices_offset;
-    		load_value(stream, indices_offset);
-    		node->indices = indices + indices_offset;
-    	}
-    	else {
-    		node->childs = pool.allocate<KMeansNode>(branching);
-    		for(int i=0; i<branching; ++i) {
-    			load_tree(stream, node->childs[i]);
-    		}
-    	}
+        /**
+         * The cluster center.
+         */
+        DistanceType* pivot;
+        /**
+         * The cluster radius.
+         */
+        DistanceType radius;
+        /**
+         * The cluster mean radius.
+         */
+        DistanceType mean_radius;
+        /**
+         * The cluster variance.
+         */
+        DistanceType variance;
+        /**
+         * The cluster size (number of points in the cluster)
+         */
+        int size;
+        /**
+         * Child nodes (only for non-terminal nodes)
+         */
+        KMeansNode** childs;
+        /**
+         * Node points (only for terminal nodes)
+         */
+        int* indices;
+        /**
+         * Level
+         */
+        int level;
+    };
+    typedef KMeansNode* KMeansNodePtr;
+
+    /**
+     * Alias definition for a nicer syntax.
+     */
+    typedef BranchStruct<KMeansNodePtr, DistanceType> BranchSt;
+
+
+
+
+    void save_tree(FILE* stream, KMeansNodePtr node)
+    {
+        save_value(stream, *node);
+        save_value(stream, *(node->pivot), (int)veclen_);
+        if (node->childs==NULL) {
+            int indices_offset = (int)(node->indices - indices_);
+            save_value(stream, indices_offset);
+        }
+        else {
+            for(int i=0; i<branching_; ++i) {
+                save_tree(stream, node->childs[i]);
+            }
+        }
+    }
+
+
+    void load_tree(FILE* stream, KMeansNodePtr& node)
+    {
+        node = pool_.allocate<KMeansNode>();
+        load_value(stream, *node);
+        node->pivot = new DistanceType[veclen_];
+        load_value(stream, *(node->pivot), (int)veclen_);
+        if (node->childs==NULL) {
+            int indices_offset;
+            load_value(stream, indices_offset);
+            node->indices = indices_ + indices_offset;
+        }
+        else {
+            node->childs = pool_.allocate<KMeansNodePtr>(branching_);
+            for(int i=0; i<branching_; ++i) {
+                load_tree(stream, node->childs[i]);
+            }
+        }
     }
 
 
     /**
-    * Helper function
-    */
-    void free_centers(KMeansNode node)
+     * Helper function
+     */
+    void free_centers(KMeansNodePtr node)
     {
         delete[] node->pivot;
         if (node->childs!=NULL) {
-            for (int k=0;k<branching;++k) {
+            for (int k=0; k<branching_; ++k) {
                 free_centers(node->childs[k]);
             }
         }
     }
 
-	/**
-	 * Computes the statistics of a node (mean, radius, variance).
-	 *
-	 * Params:
-	 *     node = the node to use
-	 *     indices = the indices of the points belonging to the node
-	 */
-	void computeNodeStatistics(KMeansNode node, int* indices, int indices_length) {
+    /**
+     * Computes the statistics of a node (mean, radius, variance).
+     *
+     * Params:
+     *     node = the node to use
+     *     indices = the indices of the points belonging to the node
+     */
+    void computeNodeStatistics(KMeansNodePtr node, int* indices, int indices_length)
+    {
 
-		double radius = 0;
-		double variance = 0;
-		DIST_TYPE* mean = new DIST_TYPE[veclen_];
-		memoryCounter += (int)(veclen_*sizeof(DIST_TYPE));
+        DistanceType radius = 0;
+        DistanceType variance = 0;
+        DistanceType* mean = new DistanceType[veclen_];
+        memoryCounter_ += int(veclen_*sizeof(DistanceType));
 
-        memset(mean,0,veclen_*sizeof(float));
+        memset(mean,0,veclen_*sizeof(DistanceType));
 
-		for (size_t i=0;i<size_;++i) {
-			ELEM_TYPE* vec = dataset[indices[i]];
-            for (size_t j=0;j<veclen_;++j) {
+        for (size_t i=0; i<size_; ++i) {
+            ElementType* vec = dataset_[indices[i]];
+            for (size_t j=0; j<veclen_; ++j) {
                 mean[j] += vec[j];
             }
-			variance += flann_dist(vec,vec+veclen_,zero());
-		}
-		for (size_t j=0;j<veclen_;++j) {
-			mean[j] /= size_;
-		}
-		variance /= size_;
-		variance -= flann_dist(mean,mean+veclen_,zero());
+            variance += distance_(vec, ZeroIterator<ElementType>(), veclen_);
+        }
+        for (size_t j=0; j<veclen_; ++j) {
+            mean[j] /= size_;
+        }
+        variance /= size_;
+        variance -= distance_(mean, ZeroIterator<ElementType>(), veclen_);
 
-		double tmp = 0;
-		for (int i=0;i<indices_length;++i) {
-			tmp = flann_dist(mean, mean + veclen_, dataset[indices[i]]);
-			if (tmp>radius) {
-				radius = tmp;
-			}
-		}
+        DistanceType tmp = 0;
+        for (int i=0; i<indices_length; ++i) {
+            tmp = distance_(mean, dataset_[indices[i]], veclen_);
+            if (tmp>radius) {
+                radius = tmp;
+            }
+        }
 
-		node->variance = (DIST_TYPE)variance;
-		node->radius = (DIST_TYPE)radius;
-		node->pivot = mean;
-	}
+        node->variance = variance;
+        node->radius = radius;
+        node->pivot = mean;
+    }
 
 
-	/**
-	 * The method responsible with actually doing the recursive hierarchical
-	 * clustering
-	 *
-	 * Params:
-	 *     node = the node to cluster
-	 *     indices = indices of the points belonging to the current node
-	 *     branching = the branching factor to use in the clustering
-	 *
-	 * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point)
-	 */
-	void computeClustering(KMeansNode node, int* indices, int indices_length, int branching, int level)
-	{
-		node->size = indices_length;
-		node->level = level;
+    /**
+     * The method responsible with actually doing the recursive hierarchical
+     * clustering
+     *
+     * Params:
+     *     node = the node to cluster
+     *     indices = indices of the points belonging to the current node
+     *     branching = the branching factor to use in the clustering
+     *
+     * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point)
+     */
+    void computeClustering(KMeansNodePtr node, int* indices, int indices_length, int branching, int level)
+    {
+        node->size = indices_length;
+        node->level = level;
 
-		if (indices_length < branching) {
-			node->indices = indices;
-            std::sort(node->indices,node->indices+indices_length);
-            node->childs = NULL;
-			return;
-		}
-
-		int* centers_idx = new int[branching];
-        int centers_length;
- 		(this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length);
-
-		if (centers_length<branching) {
+        if (indices_length < branching) {
             node->indices = indices;
             std::sort(node->indices,node->indices+indices_length);
             node->childs = NULL;
-			return;
-		}
+            return;
+        }
+
+        int* centers_idx = new int[branching];
+        int centers_length;
+        (this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length);
+
+        if (centers_length<branching) {
+            node->indices = indices;
+            std::sort(node->indices,node->indices+indices_length);
+            node->childs = NULL;
+            delete [] centers_idx;
+            return;
+        }
 
 
-        Matrix<double> dcenters(new double[branching*veclen_],branching,(long)veclen_);
+        Matrix<double> dcenters(new double[branching*veclen_],branching,veclen_);
         for (int i=0; i<centers_length; ++i) {
-        	ELEM_TYPE* vec = dataset[centers_idx[i]];
+            ElementType* vec = dataset_[centers_idx[i]];
             for (size_t k=0; k<veclen_; ++k) {
                 dcenters[i][k] = double(vec[k]);
             }
         }
-		delete[] centers_idx;
+        delete[] centers_idx;
 
-	 	float* radiuses = new float[branching];
-		int* count = new int[branching];
-        for (int i=0;i<branching;++i) {
+        DistanceType* radiuses = new DistanceType[branching];
+        int* count = new int[branching];
+        for (int i=0; i<branching; ++i) {
             radiuses[i] = 0;
             count[i] = 0;
         }
 
         //	assign points to clusters
-		int* belongs_to = new int[indices_length];
-		for (int i=0;i<indices_length;++i) {
+        int* belongs_to = new int[indices_length];
+        for (int i=0; i<indices_length; ++i) {
 
-			double sq_dist = flann_dist(dataset[indices[i]], dataset[indices[i]] + veclen_ ,dcenters[0]);
-			belongs_to[i] = 0;
-			for (int j=1;j<branching;++j) {
-				double new_sq_dist = flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_, dcenters[j]);
-				if (sq_dist>new_sq_dist) {
-					belongs_to[i] = j;
-					sq_dist = new_sq_dist;
-				}
-			}
-            if (sq_dist>radiuses[belongs_to[i]]) {
-                radiuses[belongs_to[i]] = (float)sq_dist;
+            DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
+            belongs_to[i] = 0;
+            for (int j=1; j<branching; ++j) {
+                DistanceType new_sq_dist = distance_(dataset_[indices[i]], dcenters[j], veclen_);
+                if (sq_dist>new_sq_dist) {
+                    belongs_to[i] = j;
+                    sq_dist = new_sq_dist;
+                }
             }
-			count[belongs_to[i]]++;
-		}
+            if (sq_dist>radiuses[belongs_to[i]]) {
+                radiuses[belongs_to[i]] = sq_dist;
+            }
+            count[belongs_to[i]]++;
+        }
 
-		bool converged = false;
-		int iteration = 0;
-		while (!converged && iteration<max_iter) {
-			converged = true;
-			iteration++;
+        bool converged = false;
+        int iteration = 0;
+        while (!converged && iteration<iterations_) {
+            converged = true;
+            iteration++;
 
-			// compute the new cluster centers
-			for (int i=0;i<branching;++i) {
+            // compute the new cluster centers
+            for (int i=0; i<branching; ++i) {
                 memset(dcenters[i],0,sizeof(double)*veclen_);
                 radiuses[i] = 0;
-			}
-            for (int i=0;i<indices_length;++i) {
-				ELEM_TYPE* vec = dataset[indices[i]];
-				double* center = dcenters[belongs_to[i]];
-				for (size_t k=0;k<veclen_;++k) {
-					center[k] += vec[k];
- 				}
-			}
-			for (int i=0;i<branching;++i) {
+            }
+            for (int i=0; i<indices_length; ++i) {
+                ElementType* vec = dataset_[indices[i]];
+                double* center = dcenters[belongs_to[i]];
+                for (size_t k=0; k<veclen_; ++k) {
+                    center[k] += vec[k];
+                }
+            }
+            for (int i=0; i<branching; ++i) {
                 int cnt = count[i];
-                for (size_t k=0;k<veclen_;++k) {
+                for (size_t k=0; k<veclen_; ++k) {
                     dcenters[i][k] /= cnt;
                 }
-			}
+            }
 
-			// reassign points to clusters
-			for (int i=0;i<indices_length;++i) {
-				float sq_dist = (float)flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_ ,dcenters[0]);
-				int new_centroid = 0;
-				for (int j=1;j<branching;++j) {
-					float new_sq_dist = (float)flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_,dcenters[j]);
-					if (sq_dist>new_sq_dist) {
-						new_centroid = j;
-						sq_dist = new_sq_dist;
-					}
-				}
-				if (sq_dist>radiuses[new_centroid]) {
-					radiuses[new_centroid] = sq_dist;
-				}
-				if (new_centroid != belongs_to[i]) {
-					count[belongs_to[i]]--;
-					count[new_centroid]++;
-					belongs_to[i] = new_centroid;
+            // reassign points to clusters
+            for (int i=0; i<indices_length; ++i) {
+                DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
+                int new_centroid = 0;
+                for (int j=1; j<branching; ++j) {
+                    DistanceType new_sq_dist = distance_(dataset_[indices[i]], dcenters[j], veclen_);
+                    if (sq_dist>new_sq_dist) {
+                        new_centroid = j;
+                        sq_dist = new_sq_dist;
+                    }
+                }
+                if (sq_dist>radiuses[new_centroid]) {
+                    radiuses[new_centroid] = sq_dist;
+                }
+                if (new_centroid != belongs_to[i]) {
+                    count[belongs_to[i]]--;
+                    count[new_centroid]++;
+                    belongs_to[i] = new_centroid;
 
-					converged = false;
-				}
-			}
+                    converged = false;
+                }
+            }
 
-			for (int i=0;i<branching;++i) {
-				// if one cluster converges to an empty cluster,
-				// move an element into that cluster
-				if (count[i]==0) {
-					int j = (i+1)%branching;
-					while (count[j]<=1) {
-						j = (j+1)%branching;
-					}
+            for (int i=0; i<branching; ++i) {
+                // if one cluster converges to an empty cluster,
+                // move an element into that cluster
+                if (count[i]==0) {
+                    int j = (i+1)%branching;
+                    while (count[j]<=1) {
+                        j = (j+1)%branching;
+                    }
 
-					for (int k=0;k<indices_length;++k) {
-						if (belongs_to[k]==j) {
-							belongs_to[k] = i;
-							count[j]--;
-							count[i]++;
-							break;
-						}
-					}
-					converged = false;
-				}
-			}
+                    for (int k=0; k<indices_length; ++k) {
+                        if (belongs_to[k]==j) {
+                            belongs_to[k] = i;
+                            count[j]--;
+                            count[i]++;
+                            break;
+                        }
+                    }
+                    converged = false;
+                }
+            }
 
-		}
+        }
 
-        DIST_TYPE** centers = new DIST_TYPE*[branching];
+        DistanceType** centers = new DistanceType*[branching];
 
         for (int i=0; i<branching; ++i) {
- 			centers[i] = new DIST_TYPE[veclen_];
- 			memoryCounter += (int)(veclen_*sizeof(DIST_TYPE));
+            centers[i] = new DistanceType[veclen_];
+            memoryCounter_ += veclen_*sizeof(DistanceType);
             for (size_t k=0; k<veclen_; ++k) {
-                centers[i][k] = (DIST_TYPE)dcenters[i][k];
+                centers[i][k] = (DistanceType)dcenters[i][k];
             }
- 		}
+        }
 
 
-		// compute kmeans clustering for each of the resulting clusters
-		node->childs = pool.allocate<KMeansNode>(branching);
-		int start = 0;
-		int end = start;
-		for (int c=0;c<branching;++c) {
-			int s = count[c];
+        // compute kmeans clustering for each of the resulting clusters
+        node->childs = pool_.allocate<KMeansNodePtr>(branching);
+        int start = 0;
+        int end = start;
+        for (int c=0; c<branching; ++c) {
+            int s = count[c];
 
-			double variance = 0;
-		    double mean_radius =0;
-			for (int i=0;i<indices_length;++i) {
-				if (belongs_to[i]==c) {
-					double d = flann_dist(dataset[indices[i]],dataset[indices[i]]+veclen_,zero());
-					variance += d;
-					mean_radius += sqrt(d);
+            DistanceType variance = 0;
+            DistanceType mean_radius =0;
+            for (int i=0; i<indices_length; ++i) {
+                if (belongs_to[i]==c) {
+                    DistanceType d = distance_(dataset_[indices[i]], ZeroIterator<ElementType>(), veclen_);
+                    variance += d;
+                    mean_radius += sqrt(d);
                     std::swap(indices[i],indices[end]);
                     std::swap(belongs_to[i],belongs_to[end]);
-					end++;
-				}
-			}
-			variance /= s;
-			mean_radius /= s;
-			variance -= flann_dist(centers[c],centers[c]+veclen_,zero());
+                    end++;
+                }
+            }
+            variance /= s;
+            mean_radius /= s;
+            variance -= distance_(centers[c], ZeroIterator<ElementType>(), veclen_);
 
-			node->childs[c] = pool.allocate<KMeansNodeSt>();
-			node->childs[c]->radius = radiuses[c];
-			node->childs[c]->pivot = centers[c];
-			node->childs[c]->variance = (float)variance;
-			node->childs[c]->mean_radius = (float)mean_radius;
-			node->childs[c]->indices = NULL;
-			computeClustering(node->childs[c],indices+start, end-start, branching, level+1);
-			start=end;
-		}
+            node->childs[c] = pool_.allocate<KMeansNode>();
+            node->childs[c]->radius = radiuses[c];
+            node->childs[c]->pivot = centers[c];
+            node->childs[c]->variance = variance;
+            node->childs[c]->mean_radius = mean_radius;
+            node->childs[c]->indices = NULL;
+            computeClustering(node->childs[c],indices+start, end-start, branching, level+1);
+            start=end;
+        }
 
-		delete[] dcenters.data;
-		delete[] centers;
-		delete[] radiuses;
-		delete[] count;
-		delete[] belongs_to;
-	}
+        delete[] dcenters.data;
+        delete[] centers;
+        delete[] radiuses;
+        delete[] count;
+        delete[] belongs_to;
+    }
 
 
 
-	/**
-	 * Performs one descent in the hierarchical k-means tree. The branches not
-	 * visited are stored in a priority queue.
+    /**
+     * Performs one descent in the hierarchical k-means tree. The branches not
+     * visited are stored in a priority queue.
      *
      * Params:
      *      node = node to explore
@@ -898,218 +837,279 @@ private:
      */
 
 
-	void findNN(KMeansNode node, ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, int& checks, int maxChecks,
-			Heap<BranchSt>* heap)
-	{
-		// Ignore those clusters that are too far away
-		{
-			DIST_TYPE bsq = (DIST_TYPE)flann_dist(vec, vec+veclen_, node->pivot);
-			DIST_TYPE rsq = node->radius;
-			DIST_TYPE wsq = result.worstDist();
+    void findNN(KMeansNodePtr node, ResultSet<DistanceType>& result, const ElementType* vec, int& checks, int maxChecks,
+                Heap<BranchSt>* heap)
+    {
+        // Ignore those clusters that are too far away
+        {
+            DistanceType bsq = distance_(vec, node->pivot, veclen_);
+            DistanceType rsq = node->radius;
+            DistanceType wsq = result.worstDist();
 
-			DIST_TYPE val = bsq-rsq-wsq;
-			DIST_TYPE val2 = val*val-4*rsq*wsq;
+            DistanceType val = bsq-rsq-wsq;
+            DistanceType val2 = val*val-4*rsq*wsq;
 
-	 		//if (val>0) {
-			if (val>0 && val2>0) {
-				return;
-			}
-		}
+            //if (val>0) {
+            if ((val>0)&&(val2>0)) {
+                return;
+            }
+        }
 
-		if (node->childs==NULL) {
+        if (node->childs==NULL) {
             if (checks>=maxChecks) {
                 if (result.full()) return;
             }
             checks += node->size;
-			for (int i=0;i<node->size;++i) {
-				result.addPoint(dataset[node->indices[i]], node->indices[i]);
-			}
-		}
-		else {
-			float* domain_distances = new float[branching];
-			int closest_center = exploreNodeBranches(node, vec, domain_distances, heap);
-			delete[] domain_distances;
-			findNN(node->childs[closest_center],result,vec, checks, maxChecks, heap);
-		}
-	}
+            for (int i=0; i<node->size; ++i) {
+                int index = node->indices[i];
+                DistanceType dist = distance_(dataset_[index], vec, veclen_);
+                result.addPoint(dist, index);
+            }
+        }
+        else {
+            DistanceType* domain_distances = new DistanceType[branching_];
+            int closest_center = exploreNodeBranches(node, vec, domain_distances, heap);
+            delete[] domain_distances;
+            findNN(node->childs[closest_center],result,vec, checks, maxChecks, heap);
+        }
+    }
 
-	/**
-	 * Helper function that computes the nearest childs of a node to a given query point.
-	 * Params:
-	 *     node = the node
-	 *     q = the query point
-	 *     distances = array with the distances to each child node.
-	 * Returns:
-	 */
-	int exploreNodeBranches(KMeansNode node, const ELEM_TYPE* q, float* domain_distances, Heap<BranchSt>* heap)
-	{
+    /**
+     * Helper function that computes the nearest childs of a node to a given query point.
+     * Params:
+     *     node = the node
+     *     q = the query point
+     *     distances = array with the distances to each child node.
+     * Returns:
+     */
+    int exploreNodeBranches(KMeansNodePtr node, const ElementType* q, DistanceType* domain_distances, Heap<BranchSt>* heap)
+    {
 
-		int best_index = 0;
-		domain_distances[best_index] = (float)flann_dist(q,q+veclen_,node->childs[best_index]->pivot);
-		for (int i=1;i<branching;++i) {
-			domain_distances[i] = (float)flann_dist(q,q+veclen_,node->childs[i]->pivot);
-			if (domain_distances[i]<domain_distances[best_index]) {
-				best_index = i;
-			}
-		}
+        int best_index = 0;
+        domain_distances[best_index] = distance_(q, node->childs[best_index]->pivot, veclen_);
+        for (int i=1; i<branching_; ++i) {
+            domain_distances[i] = distance_(q, node->childs[i]->pivot, veclen_);
+            if (domain_distances[i]<domain_distances[best_index]) {
+                best_index = i;
+            }
+        }
 
-//		float* best_center = node->childs[best_index]->pivot;
-		for (int i=0;i<branching;++i) {
-			if (i != best_index) {
-				domain_distances[i] -= cb_index*node->childs[i]->variance;
+        //		float* best_center = node->childs[best_index]->pivot;
+        for (int i=0; i<branching_; ++i) {
+            if (i != best_index) {
+                domain_distances[i] -= cb_index_*node->childs[i]->variance;
 
-//				float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q);
-//				if (domain_distances[i]<dist_to_border) {
-//					domain_distances[i] = dist_to_border;
-//				}
-				heap->insert(BranchSt::make_branch(node->childs[i],domain_distances[i]));
-			}
-		}
+                //				float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q);
+                //				if (domain_distances[i]<dist_to_border) {
+                //					domain_distances[i] = dist_to_border;
+                //				}
+                heap->insert(BranchSt(node->childs[i],domain_distances[i]));
+            }
+        }
 
-		return best_index;
-	}
+        return best_index;
+    }
 
 
-	/**
-	 * Function the performs exact nearest neighbor search by traversing the entire tree.
-	 */
-	void findExactNN(KMeansNode node, ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec)
-	{
-		// Ignore those clusters that are too far away
-		{
-			float bsq = (float)flann_dist(vec, vec+veclen_, node->pivot);
-			float rsq = node->radius;
-			float wsq = result.worstDist();
+    /**
+     * Function the performs exact nearest neighbor search by traversing the entire tree.
+     */
+    void findExactNN(KMeansNodePtr node, ResultSet<DistanceType>& result, const ElementType* vec)
+    {
+        // Ignore those clusters that are too far away
+        {
+            DistanceType bsq = distance_(vec, node->pivot, veclen_);
+            DistanceType rsq = node->radius;
+            DistanceType wsq = result.worstDist();
 
-			float val = bsq-rsq-wsq;
-			float val2 = val*val-4*rsq*wsq;
+            DistanceType val = bsq-rsq-wsq;
+            DistanceType val2 = val*val-4*rsq*wsq;
 
-	//  		if (val>0) {
-			if (val>0 && val2>0) {
-				return;
-			}
-		}
+            //                  if (val>0) {
+            if ((val>0)&&(val2>0)) {
+                return;
+            }
+        }
 
 
-		if (node->childs==NULL) {
-			for (int i=0;i<node->size;++i) {
-				result.addPoint(dataset[node->indices[i]], node->indices[i]);
-			}
-		}
-		else {
-			int* sort_indices = new int[branching];
+        if (node->childs==NULL) {
+            for (int i=0; i<node->size; ++i) {
+                int index = node->indices[i];
+                DistanceType dist = distance_(dataset_[index], vec, veclen_);
+                result.addPoint(dist, index);
+            }
+        }
+        else {
+            int* sort_indices = new int[branching_];
 
-			getCenterOrdering(node, vec, sort_indices);
+            getCenterOrdering(node, vec, sort_indices);
 
-			for (int i=0; i<branching; ++i) {
- 				findExactNN(node->childs[sort_indices[i]],result,vec);
-			}
+            for (int i=0; i<branching_; ++i) {
+                findExactNN(node->childs[sort_indices[i]],result,vec);
+            }
 
-			delete[] sort_indices;
-		}
-	}
+            delete[] sort_indices;
+        }
+    }
 
 
-	/**
-	 * Helper function.
-	 *
-	 * I computes the order in which to traverse the child nodes of a particular node.
-	 */
-	void getCenterOrdering(KMeansNode node, const ELEM_TYPE* q, int* sort_indices)
-	{
-		float* domain_distances = new float[branching];
-		for (int i=0;i<branching;++i) {
-			float dist = (float)flann_dist(q, q+veclen_, node->childs[i]->pivot);
+    /**
+     * Helper function.
+     *
+     * I computes the order in which to traverse the child nodes of a particular node.
+     */
+    void getCenterOrdering(KMeansNodePtr node, const ElementType* q, int* sort_indices)
+    {
+        DistanceType* domain_distances = new DistanceType[branching_];
+        for (int i=0; i<branching_; ++i) {
+            DistanceType dist = distance_(q, node->childs[i]->pivot, veclen_);
 
-			int j=0;
-			while (domain_distances[j]<dist && j<i) j++;
-			for (int k=i;k>j;--k) {
-				domain_distances[k] = domain_distances[k-1];
-				sort_indices[k] = sort_indices[k-1];
-			}
-			domain_distances[j] = dist;
-			sort_indices[j] = i;
-		}
-		delete[] domain_distances;
-	}
+            int j=0;
+            while (domain_distances[j]<dist && j<i) j++;
+            for (int k=i; k>j; --k) {
+                domain_distances[k] = domain_distances[k-1];
+                sort_indices[k] = sort_indices[k-1];
+            }
+            domain_distances[j] = dist;
+            sort_indices[j] = i;
+        }
+        delete[] domain_distances;
+    }
 
-	/**
-	 * Method that computes the squared distance from the query point q
-	 * from inside region with center c to the border between this
-	 * region and the region with center p
-	 */
-	float getDistanceToBorder(float* p, float* c, float* q)
-	{
-		float sum = 0;
-		float sum2 = 0;
+    /**
+     * Method that computes the squared distance from the query point q
+     * from inside region with center c to the border between this
+     * region and the region with center p
+     */
+    DistanceType getDistanceToBorder(DistanceType* p, DistanceType* c, DistanceType* q)
+    {
+        DistanceType sum = 0;
+        DistanceType sum2 = 0;
 
-		for (int i=0;i<veclen_; ++i) {
-			float t = c[i]-p[i];
-			sum += t*(q[i]-(c[i]+p[i])/2);
-			sum2 += t*t;
-		}
+        for (int i=0; i<veclen_; ++i) {
+            DistanceType t = c[i]-p[i];
+            sum += t*(q[i]-(c[i]+p[i])/2);
+            sum2 += t*t;
+        }
 
-		return sum*sum/sum2;
-	}
+        return sum*sum/sum2;
+    }
 
 
-	/**
-	 * Helper function the descends in the hierarchical k-means tree by spliting those clusters that minimize
-	 * the overall variance of the clustering.
-	 * Params:
-	 *     root = root node
-	 *     clusters = array with clusters centers (return value)
-	 *     varianceValue = variance of the clustering (return value)
-	 * Returns:
-	 */
-	int getMinVarianceClusters(KMeansNode root, KMeansNode* clusters, int clusters_length, float& varianceValue)
-	{
-		int clusterCount = 1;
-		clusters[0] = root;
+    /**
+     * Helper function the descends in the hierarchical k-means tree by spliting those clusters that minimize
+     * the overall variance of the clustering.
+     * Params:
+     *     root = root node
+     *     clusters = array with clusters centers (return value)
+     *     varianceValue = variance of the clustering (return value)
+     * Returns:
+     */
+    int getMinVarianceClusters(KMeansNodePtr root, KMeansNodePtr* clusters, int clusters_length, DistanceType& varianceValue)
+    {
+        int clusterCount = 1;
+        clusters[0] = root;
 
-		float meanVariance = root->variance*root->size;
+        DistanceType meanVariance = root->variance*root->size;
 
-		while (clusterCount<clusters_length) {
-			float minVariance = (std::numeric_limits<float>::max)();
-			int splitIndex = -1;
+        while (clusterCount<clusters_length) {
+            DistanceType minVariance = (std::numeric_limits<DistanceType>::max)();
+            int splitIndex = -1;
 
-			for (int i=0;i<clusterCount;++i) {
-				if (clusters[i]->childs != NULL) {
+            for (int i=0; i<clusterCount; ++i) {
+                if (clusters[i]->childs != NULL) {
 
-					float variance = meanVariance - clusters[i]->variance*clusters[i]->size;
+                    DistanceType variance = meanVariance - clusters[i]->variance*clusters[i]->size;
 
-					for (int j=0;j<branching;++j) {
-					 	variance += clusters[i]->childs[j]->variance*clusters[i]->childs[j]->size;
-					}
-					if (variance<minVariance) {
-						minVariance = variance;
-						splitIndex = i;
-					}
-				}
-			}
+                    for (int j=0; j<branching_; ++j) {
+                        variance += clusters[i]->childs[j]->variance*clusters[i]->childs[j]->size;
+                    }
+                    if (variance<minVariance) {
+                        minVariance = variance;
+                        splitIndex = i;
+                    }
+                }
+            }
 
-			if (splitIndex==-1) break;
-			if ( (branching+clusterCount-1) > clusters_length) break;
+            if (splitIndex==-1) break;
+            if ( (branching_+clusterCount-1) > clusters_length) break;
 
-			meanVariance = minVariance;
+            meanVariance = minVariance;
 
-			// split node
-			KMeansNode toSplit = clusters[splitIndex];
-			clusters[splitIndex] = toSplit->childs[0];
-			for (int i=1;i<branching;++i) {
-				clusters[clusterCount++] = toSplit->childs[i];
-			}
-		}
+            // split node
+            KMeansNodePtr toSplit = clusters[splitIndex];
+            clusters[splitIndex] = toSplit->childs[0];
+            for (int i=1; i<branching_; ++i) {
+                clusters[clusterCount++] = toSplit->childs[i];
+            }
+        }
 
-		varianceValue = meanVariance/root->size;
-		return clusterCount;
-	}
+        varianceValue = meanVariance/root->size;
+        return clusterCount;
+    }
+
+private:
+    /** The branching factor used in the hierarchical k-means clustering */
+    int branching_;
+
+    /** Maximum number of iterations to use when performing k-means clustering */
+    int iterations_;
+
+    /** Algorithm for choosing the cluster centers */
+    flann_centers_init_t centers_init_;
+
+    /**
+     * Cluster border index. This is used in the tree search phase when determining
+     * the closest cluster to explore next. A zero value takes into account only
+     * the cluster centres, a value greater then zero also take into account the size
+     * of the cluster.
+     */
+    float cb_index_;
+
+    /**
+     * The dataset used by this index
+     */
+    const Matrix<ElementType> dataset_;
+
+    /** Index parameters */
+    IndexParams index_params_;
+
+    /**
+     * Number of features in the dataset.
+     */
+    size_t size_;
+
+    /**
+     * Length of each feature.
+     */
+    size_t veclen_;
+
+    /**
+     * The root node in the tree.
+     */
+    KMeansNodePtr root_;
+
+    /**
+     *  Array of indices to vectors in the dataset.
+     */
+    int* indices_;
+
+    /**
+     * The distance
+     */
+    Distance distance_;
+
+    /**
+     * Pooled memory allocator.
+     */
+    PooledAllocator pool_;
+
+    /**
+     * Memory occupied by the index.
+     */
+    int memoryCounter_;
 };
 
+}
 
-
-//register_index(KMEANS,KMeansTree)
-
-} // namespace cvflann
-
-#endif //_OPENCV_KMEANSTREE_H_
+#endif //OPENCV_FLANN_KMEANS_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/linear_index.h b/modules/flann/include/opencv2/flann/linear_index.h
index 3a17ade65e..ecb99f281b 100644
--- a/modules/flann/include/opencv2/flann/linear_index.h
+++ b/modules/flann/include/opencv2/flann/linear_index.h
@@ -28,41 +28,40 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_LINEARSEARCH_H_
-#define _OPENCV_LINEARSEARCH_H_
-
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
+#ifndef OPENCV_FLANN_LINEAR_INDEX_H_
+#define OPENCV_FLANN_LINEAR_INDEX_H_
 
+#include "general.h"
+#include "nn_index.h"
 
 namespace cvflann
 {
 
-struct CV_EXPORTS LinearIndexParams : public IndexParams {
-	LinearIndexParams() : IndexParams(FLANN_INDEX_LINEAR) {};
-
-	void print() const
-	{
-		logger().info("Index type: %d\n",(int)algorithm);
-	}
+struct LinearIndexParams : public IndexParams
+{
+    LinearIndexParams()
+    {
+        (* this)["algorithm"] = FLANN_INDEX_LINEAR;
+    }
 };
 
-
-template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
-class LinearIndex : public NNIndex<ELEM_TYPE>
+template <typename Distance>
+class LinearIndex : public NNIndex<Distance>
 {
-	const Matrix<ELEM_TYPE> dataset;
-	const LinearIndexParams& index_params;
-
-	LinearIndex(const LinearIndex&);
-	LinearIndex& operator=(const LinearIndex&);
-
 public:
 
-	LinearIndex(const Matrix<ELEM_TYPE>& inputData, const LinearIndexParams& params = LinearIndexParams() ) :
-		dataset(inputData), index_params(params)
-	{
-	}
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
+
+    LinearIndex(const Matrix<ElementType>& inputData, const IndexParams& params = LinearIndexParams(),
+                Distance d = Distance()) :
+        dataset_(inputData), index_params_(params), distance_(d)
+    {
+    }
+
+    LinearIndex(const LinearIndex&);
+    LinearIndex& operator=(const LinearIndex&);
 
     flann_algorithm_t getType() const
     {
@@ -70,52 +69,64 @@ public:
     }
 
 
-	size_t size() const
-	{
-		return dataset.rows;
-	}
+    size_t size() const
+    {
+        return dataset_.rows;
+    }
 
-	size_t veclen() const
-	{
-		return dataset.cols;
-	}
+    size_t veclen() const
+    {
+        return dataset_.cols;
+    }
 
 
-	int usedMemory() const
-	{
-		return 0;
-	}
+    int usedMemory() const
+    {
+        return 0;
+    }
 
-	void buildIndex()
-	{
-		/* nothing to do here for linear search */
-	}
+    void buildIndex()
+    {
+        /* nothing to do here for linear search */
+    }
 
     void saveIndex(FILE*)
     {
-		/* nothing to do here for linear search */
+        /* nothing to do here for linear search */
     }
 
 
     void loadIndex(FILE*)
     {
-		/* nothing to do here for linear search */
+        /* nothing to do here for linear search */
+
+        index_params_["algorithm"] = getType();
     }
 
-	void findNeighbors(ResultSet<ELEM_TYPE>& resultSet, const ELEM_TYPE*, const SearchParams&)
-	{
-		for (size_t i=0;i<dataset.rows;++i) {
-			resultSet.addPoint(dataset[i],(int)i);
-		}
-	}
+    void findNeighbors(ResultSet<DistanceType>& resultSet, const ElementType* vec, const SearchParams& /*searchParams*/)
+    {
+        ElementType* data = dataset_.data;
+        for (size_t i = 0; i < dataset_.rows; ++i, data += dataset_.cols) {
+            DistanceType dist = distance_(data, vec, dataset_.cols);
+            resultSet.addPoint(dist, i);
+        }
+    }
 
-	const IndexParams* getParameters() const
-	{
-		return &index_params;
-	}
+    IndexParams getParameters() const
+    {
+        return index_params_;
+    }
+
+private:
+    /** The dataset */
+    const Matrix<ElementType> dataset_;
+    /** Index parameters */
+    IndexParams index_params_;
+    /** Index distance */
+    Distance distance_;
 
 };
 
-} // namespace cvflann
+}
 
-#endif // _OPENCV_LINEARSEARCH_H_
+#endif // OPENCV_FLANN_LINEAR_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/logger.h b/modules/flann/include/opencv2/flann/logger.h
index 979756d305..303f0c99fc 100644
--- a/modules/flann/include/opencv2/flann/logger.h
+++ b/modules/flann/include/opencv2/flann/logger.h
@@ -28,40 +28,36 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_LOGGER_H_
-#define _OPENCV_LOGGER_H_
+#ifndef FLANN_LOGGER_H
+#define FLANN_LOGGER_H
 
-#include <cstdio>
+#include <stdio.h>
 #include <stdarg.h>
 
+#include "defines.h"
+
+
 namespace cvflann
 {
-    
-enum flann_log_level_t {
-    FLANN_LOG_NONE = 0,
-    FLANN_LOG_FATAL = 1,
-    FLANN_LOG_ERROR = 2,
-    FLANN_LOG_WARN = 3,
-    FLANN_LOG_INFO = 4
-};
-    
-class CV_EXPORTS Logger
+
+class Logger
 {
-    FILE* stream;
-    int logLevel;
-
-public:
-
-    Logger() : stream(stdout), logLevel(FLANN_LOG_WARN) {};
+    Logger() : stream(stdout), logLevel(FLANN_LOG_WARN) {}
 
     ~Logger()
     {
-        if (stream!=NULL && stream!=stdout) {
+        if ((stream!=NULL)&&(stream!=stdout)) {
             fclose(stream);
         }
     }
 
-    void setDestination(const char* name)
+    static Logger& instance()
+    {
+        static Logger logger;
+        return logger;
+    }
+
+    void _setDestination(const char* name)
     {
         if (name==NULL) {
             stream = stdout;
@@ -74,23 +70,61 @@ public:
         }
     }
 
-    void setLevel(int level) { logLevel = level; }
+    int _log(int level, const char* fmt, va_list arglist)
+    {
+        if (level > logLevel ) return -1;
+        int ret = vfprintf(stream, fmt, arglist);
+        return ret;
+    }
 
-    int log(int level, const char* fmt, ...);
+public:
+    /**
+     * Sets the logging level. All messages with lower priority will be ignored.
+     * @param level Logging level
+     */
+    static void setLevel(int level) { instance().logLevel = level; }
 
-    int log(int level, const char* fmt, va_list arglist);
+    /**
+     * Sets the logging destination
+     * @param name Filename or NULL for console
+     */
+    static void setDestination(const char* name) { instance()._setDestination(name); }
 
-    int fatal(const char* fmt, ...);
+    /**
+     * Print log message
+     * @param level Log level
+     * @param fmt Message format
+     * @return
+     */
+    static int log(int level, const char* fmt, ...)
+    {
+        va_list arglist;
+        va_start(arglist, fmt);
+        int ret = instance()._log(level,fmt,arglist);
+        va_end(arglist);
+        return ret;
+    }
 
-    int error(const char* fmt, ...);
+#define LOG_METHOD(NAME,LEVEL) \
+    static int NAME(const char* fmt, ...) \
+    { \
+        va_list ap; \
+        va_start(ap, fmt); \
+        int ret = instance()._log(LEVEL, fmt, ap); \
+        va_end(ap); \
+        return ret; \
+    }
 
-    int warn(const char* fmt, ...);
+    LOG_METHOD(fatal, FLANN_LOG_FATAL)
+    LOG_METHOD(error, FLANN_LOG_ERROR)
+    LOG_METHOD(warn, FLANN_LOG_WARN)
+    LOG_METHOD(info, FLANN_LOG_INFO)
 
-    int info(const char* fmt, ...);
+private:
+    FILE* stream;
+    int logLevel;
 };
 
-CV_EXPORTS Logger& logger();
+}
 
-} // namespace cvflann
-
-#endif //_OPENCV_LOGGER_H_
+#endif //FLANN_LOGGER_H
diff --git a/modules/flann/include/opencv2/flann/lsh_index.h b/modules/flann/include/opencv2/flann/lsh_index.h
new file mode 100644
index 0000000000..a777990934
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/lsh_index.h
@@ -0,0 +1,388 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *************************************************************************/
+
+/***********************************************************************
+ * Author: Vincent Rabaud
+ *************************************************************************/
+
+#ifndef OPENCV_FLANN_LSH_INDEX_H_
+#define OPENCV_FLANN_LSH_INDEX_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <map>
+#include <vector>
+
+#include "general.h"
+#include "nn_index.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "heap.h"
+#include "lsh_table.h"
+#include "allocator.h"
+#include "random.h"
+#include "saving.h"
+
+namespace cvflann
+{
+
+struct LshIndexParams : public IndexParams
+{
+    LshIndexParams(unsigned int table_number, unsigned int key_size, unsigned int multi_probe_level)
+    {
+        (* this)["algorithm"] = FLANN_INDEX_LSH;
+        // The number of hash tables to use
+        (*this)["table_number"] = table_number;
+        // The length of the key in the hash tables
+        (*this)["key_size"] = key_size;
+        // Number of levels to use in multi-probe (0 for standard LSH)
+        (*this)["multi_probe_level"] = multi_probe_level;
+    }
+};
+
+/**
+ * Randomized kd-tree index
+ *
+ * Contains the k-d trees and other information for indexing a set of points
+ * for nearest-neighbor matching.
+ */
+template<typename Distance>
+class LshIndex : public NNIndex<Distance>
+{
+public:
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
+    /** Constructor
+     * @param input_data dataset with the input features
+     * @param params parameters passed to the LSH algorithm
+     * @param d the distance used
+     */
+    LshIndex(const Matrix<ElementType>& input_data, const IndexParams& params = LshIndexParams(),
+             Distance d = Distance()) :
+        dataset_(input_data), index_params_(params), distance_(d)
+    {
+        table_number_ = get_param<unsigned int>(index_params_,"table_number",12);
+        key_size_ = get_param<unsigned int>(index_params_,"key_size",20);
+        multi_probe_level_ = get_param<unsigned int>(index_params_,"multi_probe_level",2);
+
+        feature_size_ = dataset_.cols;
+        fill_xor_mask(0, key_size_, multi_probe_level_, xor_masks_);
+    }
+
+
+    LshIndex(const LshIndex&);
+    LshIndex& operator=(const LshIndex&);
+
+    /**
+     * Builds the index
+     */
+    void buildIndex()
+    {
+        tables_.resize(table_number_);
+        for (unsigned int i = 0; i < table_number_; ++i) {
+            lsh::LshTable<ElementType>& table = tables_[i];
+            table = lsh::LshTable<ElementType>(feature_size_, key_size_);
+
+            // Add the features to the table
+            table.add(dataset_);
+        }
+    }
+
+    flann_algorithm_t getType() const
+    {
+        return FLANN_INDEX_LSH;
+    }
+
+
+    void saveIndex(FILE* stream)
+    {
+        save_value(stream,table_number_);
+        save_value(stream,key_size_);
+        save_value(stream,multi_probe_level_);
+        save_value(stream, dataset_);
+    }
+
+    void loadIndex(FILE* stream)
+    {
+        load_value(stream, table_number_);
+        load_value(stream, key_size_);
+        load_value(stream, multi_probe_level_);
+        load_value(stream, dataset_);
+        // Building the index is so fast we can afford not storing it
+        buildIndex();
+
+        index_params_["algorithm"] = getType();
+        index_params_["table_number"] = table_number_;
+        index_params_["key_size"] = key_size_;
+        index_params_["multi_probe_level"] = multi_probe_level_;
+    }
+
+    /**
+     *  Returns size of index.
+     */
+    size_t size() const
+    {
+        return dataset_.rows;
+    }
+
+    /**
+     * Returns the length of an index feature.
+     */
+    size_t veclen() const
+    {
+        return feature_size_;
+    }
+
+    /**
+     * Computes the index memory usage
+     * Returns: memory used by the index
+     */
+    int usedMemory() const
+    {
+        return dataset_.rows * sizeof(int);
+    }
+
+
+    IndexParams getParameters() const
+    {
+        return index_params_;
+    }
+
+    /**
+     * \brief Perform k-nearest neighbor search
+     * \param[in] queries The query points for which to find the nearest neighbors
+     * \param[out] indices The indices of the nearest neighbors found
+     * \param[out] dists Distances to the nearest neighbors found
+     * \param[in] knn Number of nearest neighbors to return
+     * \param[in] params Search parameters
+     */
+    virtual void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
+    {
+        assert(queries.cols == veclen());
+        assert(indices.rows >= queries.rows);
+        assert(dists.rows >= queries.rows);
+        assert(int(indices.cols) >= knn);
+        assert(int(dists.cols) >= knn);
+
+
+        KNNUniqueResultSet<DistanceType> resultSet(knn);
+        for (size_t i = 0; i < queries.rows; i++) {
+            resultSet.clear();
+            findNeighbors(resultSet, queries[i], params);
+            if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices[i], dists[i], knn);
+            else resultSet.copy(indices[i], dists[i], knn);
+        }
+    }
+
+
+    /**
+     * Find set of nearest neighbors to vec. Their indices are stored inside
+     * the result object.
+     *
+     * Params:
+     *     result = the result object in which the indices of the nearest-neighbors are stored
+     *     vec = the vector for which to search the nearest neighbors
+     *     maxCheck = the maximum number of restarts (in a best-bin-first manner)
+     */
+    void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& /*searchParams*/)
+    {
+        getNeighbors(vec, result);
+    }
+
+private:
+    /** Defines the comparator on score and index
+     */
+    typedef std::pair<float, unsigned int> ScoreIndexPair;
+    struct SortScoreIndexPairOnSecond
+    {
+        bool operator()(const ScoreIndexPair& left, const ScoreIndexPair& right) const
+        {
+            return left.second < right.second;
+        }
+    };
+
+    /** Fills the different xor masks to use when getting the neighbors in multi-probe LSH
+     * @param key the key we build neighbors from
+     * @param lowest_index the lowest index of the bit set
+     * @param level the multi-probe level we are at
+     * @param xor_masks all the xor mask
+     */
+    void fill_xor_mask(lsh::BucketKey key, int lowest_index, unsigned int level,
+                       std::vector<lsh::BucketKey>& xor_masks)
+    {
+        xor_masks.push_back(key);
+        if (level == 0) return;
+        for (int index = lowest_index - 1; index >= 0; --index) {
+            // Create a new key
+            lsh::BucketKey new_key = key | (1 << index);
+            fill_xor_mask(new_key, index, level - 1, xor_masks);
+        }
+    }
+
+    /** Performs the approximate nearest-neighbor search.
+     * @param vec the feature to analyze
+     * @param do_radius flag indicating if we check the radius too
+     * @param radius the radius if it is a radius search
+     * @param do_k flag indicating if we limit the number of nn
+     * @param k_nn the number of nearest neighbors
+     * @param checked_average used for debugging
+     */
+    void getNeighbors(const ElementType* vec, bool do_radius, float radius, bool do_k, unsigned int k_nn,
+                      float& checked_average)
+    {
+        static std::vector<ScoreIndexPair> score_index_heap;
+
+        if (do_k) {
+            unsigned int worst_score = std::numeric_limits<unsigned int>::max();
+            typename std::vector<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
+            typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
+            for (; table != table_end; ++table) {
+                size_t key = table->getKey(vec);
+                std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
+                std::vector<lsh::BucketKey>::const_iterator xor_mask_end = xor_masks_.end();
+                for (; xor_mask != xor_mask_end; ++xor_mask) {
+                    size_t sub_key = key ^ (*xor_mask);
+                    const lsh::Bucket* bucket = table->getBucketFromKey(sub_key);
+                    if (bucket == 0) continue;
+
+                    // Go over each descriptor index
+                    std::vector<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
+                    std::vector<lsh::FeatureIndex>::const_iterator last_training_index = bucket->end();
+                    DistanceType hamming_distance;
+
+                    // Process the rest of the candidates
+                    for (; training_index < last_training_index; ++training_index) {
+                        hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols);
+
+                        if (hamming_distance < worst_score) {
+                            // Insert the new element
+                            score_index_heap.push_back(ScoreIndexPair(hamming_distance, training_index));
+                            std::push_heap(score_index_heap.begin(), score_index_heap.end());
+
+                            if (score_index_heap.size() > (unsigned int)k_nn) {
+                                // Remove the highest distance value as we have too many elements
+                                std::pop_heap(score_index_heap.begin(), score_index_heap.end());
+                                score_index_heap.pop_back();
+                                // Keep track of the worst score
+                                worst_score = score_index_heap.front().first;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            typename std::vector<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
+            typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
+            for (; table != table_end; ++table) {
+                size_t key = table->getKey(vec);
+                std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
+                std::vector<lsh::BucketKey>::const_iterator xor_mask_end = xor_masks_.end();
+                for (; xor_mask != xor_mask_end; ++xor_mask) {
+                    size_t sub_key = key ^ (*xor_mask);
+                    const lsh::Bucket* bucket = table->getBucketFromKey(sub_key);
+                    if (bucket == 0) continue;
+
+                    // Go over each descriptor index
+                    std::vector<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
+                    std::vector<lsh::FeatureIndex>::const_iterator last_training_index = bucket->end();
+                    DistanceType hamming_distance;
+
+                    // Process the rest of the candidates
+                    for (; training_index < last_training_index; ++training_index) {
+                        // Compute the Hamming distance
+                        hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols);
+                        if (hamming_distance < radius) score_index_heap.push_back(ScoreIndexPair(hamming_distance, training_index));
+                    }
+                }
+            }
+        }
+    }
+
+    /** Performs the approximate nearest-neighbor search.
+     * This is a slower version than the above as it uses the ResultSet
+     * @param vec the feature to analyze
+     */
+    void getNeighbors(const ElementType* vec, ResultSet<DistanceType>& result)
+    {
+        typename std::vector<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
+        typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
+        for (; table != table_end; ++table) {
+            size_t key = table->getKey(vec);
+            std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
+            std::vector<lsh::BucketKey>::const_iterator xor_mask_end = xor_masks_.end();
+            for (; xor_mask != xor_mask_end; ++xor_mask) {
+                size_t sub_key = key ^ (*xor_mask);
+                const lsh::Bucket* bucket = table->getBucketFromKey(sub_key);
+                if (bucket == 0) continue;
+
+                // Go over each descriptor index
+                std::vector<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
+                std::vector<lsh::FeatureIndex>::const_iterator last_training_index = bucket->end();
+                DistanceType hamming_distance;
+
+                // Process the rest of the candidates
+                for (; training_index < last_training_index; ++training_index) {
+                    // Compute the Hamming distance
+                    hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols);
+                    result.addPoint(hamming_distance, *training_index);
+                }
+            }
+        }
+    }
+
+    /** The different hash tables */
+    std::vector<lsh::LshTable<ElementType> > tables_;
+
+    /** The data the LSH tables where built from */
+    Matrix<ElementType> dataset_;
+
+    /** The size of the features (as ElementType[]) */
+    unsigned int feature_size_;
+
+    IndexParams index_params_;
+
+    /** table number */
+    unsigned int table_number_;
+    /** key size */
+    unsigned int key_size_;
+    /** How far should we look for neighbors in multi-probe LSH */
+    unsigned int multi_probe_level_;
+
+    /** The XOR masks to apply to a key to get the neighboring buckets */
+    std::vector<lsh::BucketKey> xor_masks_;
+
+    Distance distance_;
+};
+}
+
+#endif //OPENCV_FLANN_LSH_INDEX_H_
diff --git a/modules/flann/include/opencv2/flann/lsh_table.h b/modules/flann/include/opencv2/flann/lsh_table.h
new file mode 100644
index 0000000000..f52d5bd9ea
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/lsh_table.h
@@ -0,0 +1,477 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2009  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2009  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * THE BSD LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *************************************************************************/
+
+/***********************************************************************
+ * Author: Vincent Rabaud
+ *************************************************************************/
+
+#ifndef OPENCV_FLANN_LSH_TABLE_H_
+#define OPENCV_FLANN_LSH_TABLE_H_
+
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+#include <limits.h>
+// TODO as soon as we use C++0x, use the code in USE_UNORDERED_MAP
+#if USE_UNORDERED_MAP
+#include <unordered_map>
+#else
+#include <map>
+#endif
+#include <math.h>
+#include <stddef.h>
+
+#include "dynamic_bitset.h"
+#include "matrix.h"
+
+namespace cvflann
+{
+
+namespace lsh
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** What is stored in an LSH bucket
+ */
+typedef uint32_t FeatureIndex;
+/** The id from which we can get a bucket back in an LSH table
+ */
+typedef unsigned int BucketKey;
+
+/** A bucket in an LSH table
+ */
+typedef std::vector<FeatureIndex> Bucket;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** POD for stats about an LSH table
+ */
+struct LshStats
+{
+    std::vector<unsigned int> bucket_sizes_;
+    size_t n_buckets_;
+    size_t bucket_size_mean_;
+    size_t bucket_size_median_;
+    size_t bucket_size_min_;
+    size_t bucket_size_max_;
+    size_t bucket_size_std_dev;
+    /** Each contained vector contains three value: beginning/end for interval, number of elements in the bin
+     */
+    std::vector<std::vector<unsigned int> > size_histogram_;
+};
+
+/** Overload the << operator for LshStats
+ * @param out the streams
+ * @param stats the stats to display
+ * @return the streams
+ */
+inline std::ostream& operator <<(std::ostream& out, const LshStats& stats)
+{
+    size_t w = 20;
+    out << "Lsh Table Stats:\n" << std::setw(w) << std::setiosflags(std::ios::right) << "N buckets : "
+    << stats.n_buckets_ << "\n" << std::setw(w) << std::setiosflags(std::ios::right) << "mean size : "
+    << std::setiosflags(std::ios::left) << stats.bucket_size_mean_ << "\n" << std::setw(w)
+    << std::setiosflags(std::ios::right) << "median size : " << stats.bucket_size_median_ << "\n" << std::setw(w)
+    << std::setiosflags(std::ios::right) << "min size : " << std::setiosflags(std::ios::left)
+    << stats.bucket_size_min_ << "\n" << std::setw(w) << std::setiosflags(std::ios::right) << "max size : "
+    << std::setiosflags(std::ios::left) << stats.bucket_size_max_;
+
+    // Display the histogram
+    out << std::endl << std::setw(w) << std::setiosflags(std::ios::right) << "histogram : "
+    << std::setiosflags(std::ios::left);
+    for (std::vector<std::vector<unsigned int> >::const_iterator iterator = stats.size_histogram_.begin(), end =
+             stats.size_histogram_.end(); iterator != end; ++iterator) out << (*iterator)[0] << "-" << (*iterator)[1] << ": " << (*iterator)[2] << ",  ";
+
+    return out;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Lsh hash table. As its key is a sub-feature, and as usually
+ * the size of it is pretty small, we keep it as a continuous memory array.
+ * The value is an index in the corpus of features (we keep it as an unsigned
+ * int for pure memory reasons, it could be a size_t)
+ */
+template<typename ElementType>
+class LshTable
+{
+public:
+    /** A container of all the feature indices. Optimized for space
+     */
+#if USE_UNORDERED_MAP
+    typedef std::unordered_map<BucketKey, Bucket> BucketsSpace;
+#else
+    typedef std::map<BucketKey, Bucket> BucketsSpace;
+#endif
+
+    /** A container of all the feature indices. Optimized for speed
+     */
+    typedef std::vector<Bucket> BucketsSpeed;
+
+    /** Default constructor
+     */
+    LshTable()
+    {
+    }
+
+    /** Default constructor
+     * Create the mask and allocate the memory
+     * @param feature_size is the size of the feature (considered as a ElementType[])
+     * @param key_size is the number of bits that are turned on in the feature
+     */
+    LshTable(unsigned int /*feature_size*/, unsigned int /*key_size*/)
+    {
+        std::cerr << "LSH is not implemented for that type" << std::endl;
+        throw;
+    }
+
+    /** Add a feature to the table
+     * @param value the value to store for that feature
+     * @param feature the feature itself
+     */
+    void add(unsigned int value, const ElementType* feature)
+    {
+        // Add the value to the corresponding bucket
+        BucketKey key = getKey(feature);
+
+        switch (speed_level_) {
+        case kArray:
+            // That means we get the buckets from an array
+            buckets_speed_[key].push_back(value);
+            break;
+        case kBitsetHash:
+            // That means we can check the bitset for the presence of a key
+            key_bitset_.set(key);
+            buckets_space_[key].push_back(value);
+            break;
+        case kHash:
+        {
+            // That means we have to check for the hash table for the presence of a key
+            buckets_space_[key].push_back(value);
+            break;
+        }
+        }
+    }
+
+    /** Add a set of features to the table
+     * @param dataset the values to store
+     */
+    void add(Matrix<ElementType> dataset)
+    {
+#if USE_UNORDERED_MAP
+        if (!use_speed_) buckets_space_.rehash((buckets_space_.size() + dataset.rows) * 1.2);
+#endif
+        // Add the features to the table
+        for (unsigned int i = 0; i < dataset.rows; ++i) add(i, dataset[i]);
+        // Now that the table is full, optimize it for speed/space
+        optimize();
+    }
+
+    /** Get a bucket given the key
+     * @param key
+     * @return
+     */
+    inline const Bucket* getBucketFromKey(BucketKey key) const
+    {
+        // Generate other buckets
+        switch (speed_level_) {
+        case kArray:
+            // That means we get the buckets from an array
+            return &buckets_speed_[key];
+            break;
+        case kBitsetHash:
+            // That means we can check the bitset for the presence of a key
+            if (key_bitset_.test(key)) return &buckets_space_.find(key)->second;
+            else return 0;
+            break;
+        case kHash:
+        {
+            // That means we have to check for the hash table for the presence of a key
+            BucketsSpace::const_iterator bucket_it, bucket_end = buckets_space_.end();
+            bucket_it = buckets_space_.find(key);
+            // Stop here if that bucket does not exist
+            if (bucket_it == bucket_end) return 0;
+            else return &bucket_it->second;
+            break;
+        }
+        }
+        return 0;
+    }
+
+    /** Compute the sub-signature of a feature
+     */
+    size_t getKey(const ElementType* /*feature*/) const
+    {
+        std::cerr << "LSH is not implemented for that type" << std::endl;
+        throw;
+        return 1;
+    }
+
+    /** Get statistics about the table
+     * @return
+     */
+    LshStats getStats() const;
+
+private:
+    /** defines the speed fo the implementation
+     * kArray uses a vector for storing data
+     * kBitsetHash uses a hash map but checks for the validity of a key with a bitset
+     * kHash uses a hash map only
+     */
+    enum SpeedLevel
+    {
+        kArray, kBitsetHash, kHash
+    };
+
+    /** Initialize some variables
+     */
+    void initialize(size_t key_size)
+    {
+        speed_level_ = kHash;
+        key_size_ = key_size;
+    }
+
+    /** Optimize the table for speed/space
+     */
+    void optimize()
+    {
+        // If we are already using the fast storage, no need to do anything
+        if (speed_level_ == kArray) return;
+
+        // Use an array if it will be more than half full
+        if (buckets_space_.size() > (unsigned int)((1 << key_size_) / 2)) {
+            speed_level_ = kArray;
+            // Fill the array version of it
+            buckets_speed_.resize(1 << key_size_);
+            for (BucketsSpace::const_iterator key_bucket = buckets_space_.begin(); key_bucket != buckets_space_.end(); ++key_bucket) buckets_speed_[key_bucket->first] = key_bucket->second;
+
+            // Empty the hash table
+            buckets_space_.clear();
+            return;
+        }
+
+        // If the bitset is going to use less than 10% of the RAM of the hash map (at least 1 size_t for the key and two
+        // for the vector) or less than 512MB (key_size_ <= 30)
+        if (((std::max(buckets_space_.size(), buckets_speed_.size()) * CHAR_BIT * 3 * sizeof(BucketKey)) / 10
+             >= size_t(1 << key_size_)) || (key_size_ <= 32)) {
+            speed_level_ = kBitsetHash;
+            key_bitset_.resize(1 << key_size_);
+            key_bitset_.reset();
+            // Try with the BucketsSpace
+            for (BucketsSpace::const_iterator key_bucket = buckets_space_.begin(); key_bucket != buckets_space_.end(); ++key_bucket) key_bitset_.set(key_bucket->first);
+        }
+        else {
+            speed_level_ = kHash;
+            key_bitset_.clear();
+        }
+    }
+
+    /** The vector of all the buckets if they are held for speed
+     */
+    BucketsSpeed buckets_speed_;
+
+    /** The hash table of all the buckets in case we cannot use the speed version
+     */
+    BucketsSpace buckets_space_;
+
+    /** What is used to store the data */
+    SpeedLevel speed_level_;
+
+    /** If the subkey is small enough, it will keep track of which subkeys are set through that bitset
+     * That is just a speedup so that we don't look in the hash table (which can be mush slower that checking a bitset)
+     */
+    DynamicBitset key_bitset_;
+
+    /** The size of the sub-signature in bits
+     */
+    unsigned int key_size_;
+
+    // Members only used for the unsigned char specialization
+    /** The mask to apply to a feature to get the hash key
+     * Only used in the unsigned char case
+     */
+    std::vector<size_t> mask_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Specialization for unsigned char
+
+template<>
+inline LshTable<unsigned char>::LshTable(unsigned int feature_size, unsigned int subsignature_size)
+{
+    initialize(subsignature_size);
+    // Allocate the mask
+    mask_ = std::vector<size_t>((size_t)ceil((float)(feature_size * sizeof(char)) / (float)sizeof(size_t)), 0);
+
+    // A bit brutal but fast to code
+    std::vector<size_t> indices(feature_size * CHAR_BIT);
+    for (size_t i = 0; i < feature_size * CHAR_BIT; ++i) indices[i] = i;
+    std::random_shuffle(indices.begin(), indices.end());
+
+    // Generate a random set of order of subsignature_size_ bits
+    for (unsigned int i = 0; i < key_size_; ++i) {
+        size_t index = indices[i];
+
+        // Set that bit in the mask
+        size_t divisor = CHAR_BIT * sizeof(size_t);
+        size_t idx = index / divisor; //pick the right size_t index
+        mask_[idx] |= size_t(1) << (index % divisor); //use modulo to find the bit offset
+    }
+
+    // Set to 1 if you want to display the mask for debug
+#if 0
+    {
+        size_t bcount = 0;
+        BOOST_FOREACH(size_t mask_block, mask_){
+            out << std::setw(sizeof(size_t) * CHAR_BIT / 4) << std::setfill('0') << std::hex << mask_block
+                << std::endl;
+            bcount += __builtin_popcountll(mask_block);
+        }
+        out << "bit count : " << std::dec << bcount << std::endl;
+        out << "mask size : " << mask_.size() << std::endl;
+        return out;
+    }
+#endif
+}
+
+/** Return the Subsignature of a feature
+ * @param feature the feature to analyze
+ */
+template<>
+inline size_t LshTable<unsigned char>::getKey(const unsigned char* feature) const
+{
+    // no need to check if T is dividable by sizeof(size_t) like in the Hamming
+    // distance computation as we have a mask
+    const size_t* feature_block_ptr = reinterpret_cast<const size_t*> (feature);
+
+    // Figure out the subsignature of the feature
+    // Given the feature ABCDEF, and the mask 001011, the output will be
+    // 000CEF
+    size_t subsignature = 0;
+    size_t bit_index = 1;
+
+    for (std::vector<size_t>::const_iterator pmask_block = mask_.begin(); pmask_block != mask_.end(); ++pmask_block) {
+        // get the mask and signature blocks
+        size_t feature_block = *feature_block_ptr;
+        size_t mask_block = *pmask_block;
+        while (mask_block) {
+            // Get the lowest set bit in the mask block
+            size_t lowest_bit = mask_block & (-(ptrdiff_t)mask_block);
+            // Add it to the current subsignature if necessary
+            subsignature += (feature_block & lowest_bit) ? bit_index : 0;
+            // Reset the bit in the mask block
+            mask_block ^= lowest_bit;
+            // increment the bit index for the subsignature
+            bit_index <<= 1;
+        }
+        // Check the next feature block
+        ++feature_block_ptr;
+    }
+    return subsignature;
+}
+
+template<>
+inline LshStats LshTable<unsigned char>::getStats() const
+{
+    LshStats stats;
+    stats.bucket_size_mean_ = 0;
+    if ((buckets_speed_.empty()) && (buckets_space_.empty())) {
+        stats.n_buckets_ = 0;
+        stats.bucket_size_median_ = 0;
+        stats.bucket_size_min_ = 0;
+        stats.bucket_size_max_ = 0;
+        return stats;
+    }
+
+    if (!buckets_speed_.empty()) {
+        for (BucketsSpeed::const_iterator pbucket = buckets_speed_.begin(); pbucket != buckets_speed_.end(); ++pbucket) {
+            stats.bucket_sizes_.push_back(pbucket->size());
+            stats.bucket_size_mean_ += pbucket->size();
+        }
+        stats.bucket_size_mean_ /= buckets_speed_.size();
+        stats.n_buckets_ = buckets_speed_.size();
+    }
+    else {
+        for (BucketsSpace::const_iterator x = buckets_space_.begin(); x != buckets_space_.end(); ++x) {
+            stats.bucket_sizes_.push_back(x->second.size());
+            stats.bucket_size_mean_ += x->second.size();
+        }
+        stats.bucket_size_mean_ /= buckets_space_.size();
+        stats.n_buckets_ = buckets_space_.size();
+    }
+
+    std::sort(stats.bucket_sizes_.begin(), stats.bucket_sizes_.end());
+
+    //  BOOST_FOREACH(int size, stats.bucket_sizes_)
+    //          std::cout << size << " ";
+    //  std::cout << std::endl;
+    stats.bucket_size_median_ = stats.bucket_sizes_[stats.bucket_sizes_.size() / 2];
+    stats.bucket_size_min_ = stats.bucket_sizes_.front();
+    stats.bucket_size_max_ = stats.bucket_sizes_.back();
+
+    // TODO compute mean and std
+    /*float mean, stddev;
+       stats.bucket_size_mean_ = mean;
+       stats.bucket_size_std_dev = stddev;*/
+
+    // Include a histogram of the buckets
+    unsigned int bin_start = 0;
+    unsigned int bin_end = 20;
+    bool is_new_bin = true;
+    for (std::vector<unsigned int>::iterator iterator = stats.bucket_sizes_.begin(), end = stats.bucket_sizes_.end(); iterator
+         != end; )
+        if (*iterator < bin_end) {
+            if (is_new_bin) {
+                stats.size_histogram_.push_back(std::vector<unsigned int>(3, 0));
+                stats.size_histogram_.back()[0] = bin_start;
+                stats.size_histogram_.back()[1] = bin_end - 1;
+                is_new_bin = false;
+            }
+            ++stats.size_histogram_.back()[2];
+            ++iterator;
+        }
+        else {
+            bin_start += 20;
+            bin_end += 20;
+            is_new_bin = true;
+        }
+
+    return stats;
+}
+
+// End the two namespaces
+}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif /* OPENCV_FLANN_LSH_TABLE_H_ */
diff --git a/modules/flann/include/opencv2/flann/matrix.h b/modules/flann/include/opencv2/flann/matrix.h
index 170dc6ddc1..51b6c6352c 100644
--- a/modules/flann/include/opencv2/flann/matrix.h
+++ b/modules/flann/include/opencv2/flann/matrix.h
@@ -28,60 +28,58 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_DATASET_H_
-#define _OPENCV_DATASET_H_
+#ifndef OPENCV_FLANN_DATASET_H_
+#define OPENCV_FLANN_DATASET_H_
 
 #include <stdio.h>
 
-#include "opencv2/flann/general.h"
+#include "general.h"
 
-
-namespace cvflann 
+namespace cvflann
 {
 
 /**
-* Class that implements a simple rectangular matrix stored in a memory buffer and
-* provides convenient matrix-like access using the [] operators.
-*/
+ * Class that implements a simple rectangular matrix stored in a memory buffer and
+ * provides convenient matrix-like access using the [] operators.
+ */
 template <typename T>
-class Matrix {
+class Matrix
+{
 public:
+    typedef T type;
+
     size_t rows;
     size_t cols;
+    size_t stride;
     T* data;
 
-    Matrix() : rows(0), cols(0), data(NULL)
+    Matrix() : rows(0), cols(0), stride(0), data(NULL)
     {
     }
 
-    Matrix(T* data_, long rows_, long cols_) :
-    	 rows(rows_), cols(cols_), data(data_)
-	{
-	}
+    Matrix(T* data_, size_t rows_, size_t cols_, size_t stride_ = 0) :
+        rows(rows_), cols(cols_),  stride(stride_), data(data_)
+    {
+        if (stride==0) stride = cols;
+    }
 
     /**
      * Convenience function for deallocating the storage data.
      */
-    void release()
+    FLANN_DEPRECATED void free()
     {
-        if (data!=NULL) delete[] data;
+        fprintf(stderr, "The cvflann::Matrix<T>::free() method is deprecated "
+                "and it does not do any memory deallocation any more.  You are"
+                "responsible for deallocating the matrix memory (by doing"
+                "'delete[] matrix.data' for example)");
     }
 
-	~Matrix()
-	{
-	}
-
     /**
-    * Operator that return a (pointer to a) row of the data.
-    */
-    T* operator[](size_t index)
-    {
-        return data+index*cols;
-    }
-
+     * Operator that return a (pointer to a) row of the data.
+     */
     T* operator[](size_t index) const
     {
-        return data+index*cols;
+        return data+index*stride;
     }
 };
 
@@ -95,7 +93,7 @@ public:
     flann_datatype_t type;
 
     UntypedMatrix(void* data_, long rows_, long cols_) :
-    	 rows(rows_), cols(cols_), data(data_)
+        rows(rows_), cols(cols_), data(data_)
     {
     }
 
@@ -113,6 +111,6 @@ public:
 
 
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_DATASET_H_
+#endif //OPENCV_FLANN_DATASET_H_
diff --git a/modules/flann/include/opencv2/flann/miniflann.hpp b/modules/flann/include/opencv2/flann/miniflann.hpp
new file mode 100644
index 0000000000..b36cba1326
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/miniflann.hpp
@@ -0,0 +1,158 @@
+/*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_MINIFLANN_HPP_
+#define _OPENCV_MINIFLANN_HPP_
+
+#ifdef __cplusplus
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/flann/defines.h"
+
+namespace cv
+{
+ 
+namespace flann
+{
+    using namespace cvflann;
+
+
+struct CV_EXPORTS IndexParams
+{
+    IndexParams();
+    ~IndexParams();
+    
+    std::string getString(const std::string& key, const std::string& defaultVal=std::string()) const;
+    int getInt(const std::string& key, int defaultVal=-1) const;
+    double getDouble(const std::string& key, double defaultVal=-1) const;
+    
+    void setString(const std::string& key, const std::string& value);
+    void setInt(const std::string& key, int value);
+    void setDouble(const std::string& key, double value);
+    void setFloat(const std::string& key, float value);
+    void setBool(const std::string& key, bool value);
+    void setAlgorithm(const std::string& key, int value);
+    
+    void getAll(std::vector<std::string>& names,
+                std::vector<int>& types,
+                std::vector<std::string>& strValues,
+                std::vector<double>& numValues) const;
+    
+    void* params;
+};    
+
+struct CV_EXPORTS KDTreeIndexParams : public IndexParams
+{
+    KDTreeIndexParams(int trees=4);
+};
+    
+struct CV_EXPORTS LinearIndexParams : public IndexParams
+{
+    LinearIndexParams();
+};
+
+struct CV_EXPORTS CompositeIndexParams : public IndexParams
+{
+    CompositeIndexParams(int trees = 4, int branching = 32, int iterations = 11,
+                         cvflann::flann_centers_init_t centers_init = cvflann::FLANN_CENTERS_RANDOM, float cb_index = 0.2 );
+};
+
+struct CV_EXPORTS AutotunedIndexParams : public IndexParams
+{
+    AutotunedIndexParams(float target_precision = 0.8, float build_weight = 0.01,
+                         float memory_weight = 0, float sample_fraction = 0.1);
+};
+    
+struct CV_EXPORTS KMeansIndexParams : public IndexParams
+{
+    KMeansIndexParams(int branching = 32, int iterations = 11,
+                      cvflann::flann_centers_init_t centers_init = cvflann::FLANN_CENTERS_RANDOM, float cb_index = 0.2 );
+};
+
+struct CV_EXPORTS LshIndexParams : public IndexParams
+{
+    LshIndexParams(int table_number, int key_size, int multi_probe_level);
+};
+    
+struct CV_EXPORTS SavedIndexParams : public IndexParams
+{
+    SavedIndexParams(const std::string& filename);
+};    
+    
+struct CV_EXPORTS SearchParams : public IndexParams
+{
+    SearchParams( int checks = 32, float eps = 0, bool sorted = true );
+};    
+    
+class CV_EXPORTS_W Index
+{
+public:
+    CV_WRAP Index();
+    CV_WRAP Index(InputArray features, const IndexParams& params, cvflann::flann_distance_t distType=cvflann::FLANN_DIST_L2);
+    virtual ~Index();
+    
+    CV_WRAP virtual void build(InputArray features, const IndexParams& params, cvflann::flann_distance_t distType=cvflann::FLANN_DIST_L2);
+    CV_WRAP virtual void knnSearch(InputArray query, OutputArray indices, 
+                   OutputArray dists, int knn, const SearchParams& params=SearchParams());
+    
+    CV_WRAP virtual int radiusSearch(InputArray query, OutputArray indices,
+                             OutputArray dists, double radius, int maxResults,
+                             const SearchParams& params=SearchParams());
+    
+    CV_WRAP virtual void save(const std::string& filename) const;
+    CV_WRAP virtual bool load(InputArray features, const std::string& filename);
+    CV_WRAP virtual void release();
+    CV_WRAP cvflann::flann_distance_t getDistance() const;
+    CV_WRAP cvflann::flann_algorithm_t getAlgorithm() const;
+    
+protected:
+    cvflann::flann_distance_t distType;
+    cvflann::flann_algorithm_t algo;
+    int featureType;
+    void* index;
+};
+        
+} } // namespace cv::flann
+
+#endif // __cplusplus
+
+#endif
diff --git a/modules/flann/include/opencv2/flann/nn_index.h b/modules/flann/include/opencv2/flann/nn_index.h
index 081f9aff6b..da4dd7f0d8 100644
--- a/modules/flann/include/opencv2/flann/nn_index.h
+++ b/modules/flann/include/opencv2/flann/nn_index.h
@@ -28,79 +28,152 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_NNINDEX_H_
-#define _OPENCV_NNINDEX_H_
+#ifndef FLANN_NNINDEX_H
+#define FLANN_NNINDEX_H
 
 #include <string>
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/matrix.h"
+#include "general.h"
+#include "matrix.h"
+#include "result_set.h"
+#include "params.h"
 
 namespace cvflann
 {
 
-
-template <typename ELEM_TYPE>
-class ResultSet;
-
 /**
-* Nearest-neighbour index base class
-*/
-template <typename ELEM_TYPE>
+ * Nearest-neighbour index base class
+ */
+template <typename Distance>
 class NNIndex
 {
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+
 public:
 
-	virtual ~NNIndex() {};
+    virtual ~NNIndex() {}
 
-	/**
-	Method responsible with building the index.
-	*/
-	virtual void buildIndex() = 0;
+    /**
+     * \brief Builds the index
+     */
+    virtual void buildIndex() = 0;
 
-	/**
-	Saves the index to a stream
-	*/
-	virtual void saveIndex(FILE* stream) = 0;
+    /**
+     * \brief Perform k-nearest neighbor search
+     * \param[in] queries The query points for which to find the nearest neighbors
+     * \param[out] indices The indices of the nearest neighbors found
+     * \param[out] dists Distances to the nearest neighbors found
+     * \param[in] knn Number of nearest neighbors to return
+     * \param[in] params Search parameters
+     */
+    virtual void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
+    {
+        assert(queries.cols == veclen());
+        assert(indices.rows >= queries.rows);
+        assert(dists.rows >= queries.rows);
+        assert(int(indices.cols) >= knn);
+        assert(int(dists.cols) >= knn);
 
-	/**
-	Loads the index from a stream
-	*/
-	virtual void loadIndex(FILE* stream) = 0;
+#if 0
+        KNNResultSet<DistanceType> resultSet(knn);
+        for (size_t i = 0; i < queries.rows; i++) {
+            resultSet.init(indices[i], dists[i]);
+            findNeighbors(resultSet, queries[i], params);
+        }
+#else
+        KNNUniqueResultSet<DistanceType> resultSet(knn);
+        for (size_t i = 0; i < queries.rows; i++) {
+            resultSet.clear();
+            findNeighbors(resultSet, queries[i], params);
+            if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices[i], dists[i], knn);
+            else resultSet.copy(indices[i], dists[i], knn);
+        }
+#endif
+    }
 
-	/**
-	Method that searches for nearest-neighbors
-	*/
-	virtual void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams) = 0;
+    /**
+     * \brief Perform radius search
+     * \param[in] query The query point
+     * \param[out] indices The indinces of the neighbors found within the given radius
+     * \param[out] dists The distances to the nearest neighbors found
+     * \param[in] radius The radius used for search
+     * \param[in] params Search parameters
+     * \returns Number of neighbors found
+     */
+    virtual int radiusSearch(const Matrix<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& dists, float radius, const SearchParams& params)
+    {
+        if (query.rows != 1) {
+            fprintf(stderr, "I can only search one feature at a time for range search\n");
+            return -1;
+        }
+        assert(query.cols == veclen());
+        assert(indices.cols == dists.cols);
 
-	/**
-	Number of features in this index.
-	*/
-	virtual size_t size() const = 0;
+        int n = 0;
+        int* indices_ptr = NULL;
+        DistanceType* dists_ptr = NULL;
+        if (indices.cols > 0) {
+            n = indices.cols;
+            indices_ptr = indices[0];
+            dists_ptr = dists[0];
+        }
 
-	/**
-	The length of each vector in this index.
-	*/
-	virtual size_t veclen() const = 0;
+        RadiusUniqueResultSet<DistanceType> resultSet(radius);
+        resultSet.clear();
+        findNeighbors(resultSet, query[0], params);
+        if (n>0) {
+            if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices_ptr, dists_ptr, n);
+            else resultSet.copy(indices_ptr, dists_ptr, n);
+        }
 
-	/**
-	The amount of memory (in bytes) this index uses.
-	*/
-	virtual int usedMemory() const = 0;
+        return resultSet.size();
+    }
 
-	/**
-	* Algorithm name
-	*/
-	virtual flann_algorithm_t getType() const = 0;
+    /**
+     * \brief Saves the index to a stream
+     * \param stream The stream to save the index to
+     */
+    virtual void saveIndex(FILE* stream) = 0;
 
-	/**
-	 * Returns the parameters used for the index
-	 */
-	virtual const IndexParams* getParameters() const = 0;
+    /**
+     * \brief Loads the index from a stream
+     * \param stream The stream from which the index is loaded
+     */
+    virtual void loadIndex(FILE* stream) = 0;
 
+    /**
+     * \returns number of features in this index.
+     */
+    virtual size_t size() const = 0;
+
+    /**
+     * \returns The dimensionality of the features in this index.
+     */
+    virtual size_t veclen() const = 0;
+
+    /**
+     * \returns The amount of memory (in bytes) used by the index.
+     */
+    virtual int usedMemory() const = 0;
+
+    /**
+     * \returns The index type (kdtree, kmeans,...)
+     */
+    virtual flann_algorithm_t getType() const = 0;
+
+    /**
+     * \returns The index parameters
+     */
+    virtual IndexParams getParameters() const = 0;
+
+
+    /**
+     * \brief Method that searches for nearest-neighbours
+     */
+    virtual void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) = 0;
 };
 
+}
 
-} // namespace cvflann
-
-#endif //_OPENCV_NNINDEX_H_
+#endif //FLANN_NNINDEX_H
diff --git a/modules/flann/include/opencv2/flann/object_factory.h b/modules/flann/include/opencv2/flann/object_factory.h
index 5c51e0db90..7f971c5a31 100644
--- a/modules/flann/include/opencv2/flann/object_factory.h
+++ b/modules/flann/include/opencv2/flann/object_factory.h
@@ -28,67 +28,64 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_OBJECT_FACTORY_H_
-#define _OPENCV_OBJECT_FACTORY_H_
+#ifndef OPENCV_FLANN_OBJECT_FACTORY_H_
+#define OPENCV_FLANN_OBJECT_FACTORY_H_
 
-#include "opencv2/core/types_c.h"
 #include <map>
 
 namespace cvflann
 {
 
-template<typename BaseClass, typename DerivedClass>
-BaseClass* createObject()
+class CreatorNotFound
 {
-	return new DerivedClass();
-}
-
-template<typename BaseClass, typename UniqueIdType>
-class ObjectFactory
-{
-	typedef BaseClass* (*CreateObjectFunc)();
-	std::map<UniqueIdType, CreateObjectFunc> object_registry;
-
-	// singleton class, private constructor
-	//ObjectFactory() {};
-
-public:
-   typedef typename std::map<UniqueIdType, CreateObjectFunc>::iterator Iterator;
-
-
-   template<typename DerivedClass>
-   bool register_(UniqueIdType id)
-   {
-      if (object_registry.find(id) != object_registry.end())
-               return false;
-
-      object_registry[id] = &createObject<BaseClass, DerivedClass>;
-      return true;
-   }
-
-   bool unregister(UniqueIdType id)
-   {
-      return (object_registry.erase(id) == 1);
-   }
-
-   BaseClass* create(UniqueIdType id)
-   {
-      Iterator iter = object_registry.find(id);
-
-      if (iter == object_registry.end())
-         return NULL;
-
-      return ((*iter).second)();
-   }
-
-   /*static ObjectFactory<BaseClass,UniqueIdType>& instance()
-   {
-	   static ObjectFactory<BaseClass,UniqueIdType> the_factory;
-	   return the_factory;
-   }*/
-
 };
 
-} // namespace cvflann
+template<typename BaseClass,
+         typename UniqueIdType,
+         typename ObjectCreator = BaseClass* (*)()>
+class ObjectFactory
+{
+    typedef ObjectFactory<BaseClass,UniqueIdType,ObjectCreator> ThisClass;
+    typedef std::map<UniqueIdType, ObjectCreator> ObjectRegistry;
 
-#endif /* OBJECT_FACTORY_H_ */
+    // singleton class, private constructor
+    ObjectFactory() {}
+
+public:
+
+    bool subscribe(UniqueIdType id, ObjectCreator creator)
+    {
+        if (object_registry.find(id) != object_registry.end()) return false;
+
+        object_registry[id] = creator;
+        return true;
+    }
+
+    bool unregister(UniqueIdType id)
+    {
+        return object_registry.erase(id) == 1;
+    }
+
+    ObjectCreator create(UniqueIdType id)
+    {
+        typename ObjectRegistry::const_iterator iter = object_registry.find(id);
+
+        if (iter == object_registry.end()) {
+            throw CreatorNotFound();
+        }
+
+        return iter->second;
+    }
+
+    static ThisClass& instance()
+    {
+        static ThisClass the_factory;
+        return the_factory;
+    }
+private:
+    ObjectRegistry object_registry;
+};
+
+}
+
+#endif /* OPENCV_FLANN_OBJECT_FACTORY_H_ */
diff --git a/modules/flann/include/opencv2/flann/params.h b/modules/flann/include/opencv2/flann/params.h
new file mode 100644
index 0000000000..9f3a468c85
--- /dev/null
+++ b/modules/flann/include/opencv2/flann/params.h
@@ -0,0 +1,97 @@
+/***********************************************************************
+ * Software License Agreement (BSD License)
+ *
+ * Copyright 2008-2011  Marius Muja (mariusm@cs.ubc.ca). All rights reserved.
+ * Copyright 2008-2011  David G. Lowe (lowe@cs.ubc.ca). All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *************************************************************************/
+
+
+#ifndef OPENCV_FLANN_PARAMS_H_
+#define OPENCV_FLANN_PARAMS_H_
+
+#include "any.h"
+#include "general.h"
+#include <iostream>
+#include <map>
+
+
+namespace cvflann
+{
+
+typedef cdiggins::any any;
+typedef std::map<std::string, any> IndexParams;
+
+struct SearchParams : public IndexParams
+{
+    SearchParams(int checks = 32, float eps = 0, bool sorted = true )
+    {
+        // how many leafs to visit when searching for neighbours (-1 for unlimited)
+        (*this)["checks"] = checks;
+        // search for eps-approximate neighbours (default: 0)
+        (*this)["eps"] = eps;
+        // only for radius search, require neighbours sorted by distance (default: true)
+        (*this)["sorted"] = sorted;
+    }
+};
+
+
+template<typename T>
+T get_param(const IndexParams& params, std::string name, const T& default_value)
+{
+    IndexParams::const_iterator it = params.find(name);
+    if (it != params.end()) {
+        return it->second.cast<T>();
+    }
+    else {
+        return default_value;
+    }
+}
+
+template<typename T>
+T get_param(const IndexParams& params, std::string name)
+{
+    IndexParams::const_iterator it = params.find(name);
+    if (it != params.end()) {
+        return it->second.cast<T>();
+    }
+    else {
+        throw FLANNException(std::string("Missing parameter '")+name+std::string("' in the parameters given"));
+    }
+}
+
+inline void print_params(const IndexParams& params)
+{
+    IndexParams::const_iterator it;
+
+    for(it=params.begin(); it!=params.end(); ++it) {
+        std::cout << it->first << " : " << it->second << std::endl;
+    }
+}
+
+
+
+}
+
+
+#endif /* OPENCV_FLANN_PARAMS_H_ */
diff --git a/modules/flann/include/opencv2/flann/random.h b/modules/flann/include/opencv2/flann/random.h
index d29a123963..b702807425 100644
--- a/modules/flann/include/opencv2/flann/random.h
+++ b/modules/flann/include/opencv2/flann/random.h
@@ -28,106 +28,108 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_RANDOM_H_
-#define _OPENCV_RANDOM_H_
+#ifndef FLANN_RANDOM_H
+#define FLANN_RANDOM_H
 
 #include <algorithm>
 #include <cstdlib>
-#include <cassert>
+#include <vector>
 
+#include "general.h"
 
 namespace cvflann
 {
 
 /**
  * Seeds the random number generator
+ *  @param seed Random seed
  */
-CV_EXPORTS void seed_random(unsigned int seed);
+inline void seed_random(unsigned int seed)
+{
+    srand(seed);
+}
 
 /*
  * Generates a random double value.
  */
-CV_EXPORTS double rand_double(double high = 1.0, double low=0);
-
-/*
- * Generates a random integer value.
+/**
+ * Generates a random double value.
+ * @param high Upper limit
+ * @param low Lower limit
+ * @return Random double value
  */
-CV_EXPORTS int rand_int(int high = RAND_MAX, int low = 0);
+inline double rand_double(double high = 1.0, double low = 0)
+{
+    return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0)));
+}
 
+/**
+ * Generates a random integer value.
+ * @param high Upper limit
+ * @param low Lower limit
+ * @return Random integer value
+ */
+inline int rand_int(int high = RAND_MAX, int low = 0)
+{
+    return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0)));
+}
 
 /**
  * Random number generator that returns a distinct number from
  * the [0,n) interval each time.
- *
- * TODO: improve on this to use a generator function instead of an
- * array of randomly permuted numbers
  */
-class CV_EXPORTS UniqueRandom
+class UniqueRandom
 {
-	int* vals;
-    int size;
-	int counter;
+    std::vector<int> vals_;
+    int size_;
+    int counter_;
 
 public:
-	/**
-	 * Constructor.
-	 * Params:
-	 *     n = the size of the interval from which to generate
-	 *     		random numbers.
-	 */
-	UniqueRandom(int n) : vals(NULL) {
-		init(n);
-	}
+    /**
+     * Constructor.
+     * @param n Size of the interval from which to generate
+     * @return
+     */
+    UniqueRandom(int n)
+    {
+        init(n);
+    }
 
-	~UniqueRandom()
-	{
-		delete[] vals;
-	}
+    /**
+     * Initializes the number generator.
+     * @param n the size of the interval from which to generate random numbers.
+     */
+    void init(int n)
+    {
+        // create and initialize an array of size n
+        vals_.resize(n);
+        size_ = n;
+        for (int i = 0; i < size_; ++i) vals_[i] = i;
 
-	/**
-	 * Initializes the number generator.
-	 * Params:
-	 * 		n = the size of the interval from which to generate
-	 *     		random numbers.
-	 */
-	void init(int n)
-	{
-    	// create and initialize an array of size n
-		if (vals == NULL || n!=size) {
-            delete[] vals;
-	        size = n;
-            vals = new int[size];
-    	}
-    	for(int i=0;i<size;++i) {
-			vals[i] = i;
-		}
+        // shuffle the elements in the array
+        std::random_shuffle(vals_.begin(), vals_.end());
 
-		// shuffle the elements in the array
-        // Fisher-Yates shuffle
-		for (int i=size;i>0;--i) {
-// 			int rand = cast(int) (drand48() * n);
-			int rnd = rand_int(i);
-			assert(rnd >=0 && rnd < i);
-            std::swap(vals[i-1], vals[rnd]);
-		}
+        counter_ = 0;
+    }
 
-		counter = 0;
-	}
-
-	/**
-	 * Return a distinct random integer in greater or equal to 0 and less
-	 * than 'n' on each call. It should be called maximum 'n' times.
-	 * Returns: a random integer
-	 */
-	int next() {
-		if (counter==size) {
-			return -1;
-		} else {
-			return vals[counter++];
-		}
-	}
+    /**
+     * Return a distinct random integer in greater or equal to 0 and less
+     * than 'n' on each call. It should be called maximum 'n' times.
+     * Returns: a random integer
+     */
+    int next()
+    {
+        if (counter_ == size_) {
+            return -1;
+        }
+        else {
+            return vals_[counter_++];
+        }
+    }
 };
 
-} // namespace cvflann
+}
+
+#endif //FLANN_RANDOM_H
+
 
-#endif //_OPENCV_RANDOM_H_
diff --git a/modules/flann/include/opencv2/flann/result_set.h b/modules/flann/include/opencv2/flann/result_set.h
index 5b1a8e2adb..047466faa7 100644
--- a/modules/flann/include/opencv2/flann/result_set.h
+++ b/modules/flann/include/opencv2/flann/result_set.h
@@ -28,291 +28,516 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_RESULTSET_H_
-#define _OPENCV_RESULTSET_H_
-
+#ifndef FLANN_RESULTSET_H
+#define FLANN_RESULTSET_H
 
 #include <algorithm>
+#include <cstring>
+#include <iostream>
 #include <limits>
+#include <set>
 #include <vector>
-#include "opencv2/flann/dist.h"
-
 
 namespace cvflann
 {
 
 /* This record represents a branch point when finding neighbors in
-	the tree.  It contains a record of the minimum distance to the query
-	point, as well as the node at which the search resumes.
-*/
+    the tree.  It contains a record of the minimum distance to the query
+    point, as well as the node at which the search resumes.
+ */
 
-template <typename T>
-struct BranchStruct {
-	T node;           /* Tree node at which search resumes */
-	float mindistsq;     /* Minimum distance to query for all nodes below. */
+template <typename T, typename DistanceType>
+struct BranchStruct
+{
+    T node;           /* Tree node at which search resumes */
+    DistanceType mindist;     /* Minimum distance to query for all nodes below. */
 
-	bool operator<(const BranchStruct<T>& rhs)
-	{
-        return mindistsq<rhs.mindistsq;
-	}
+    BranchStruct() {}
+    BranchStruct(const T& aNode, DistanceType dist) : node(aNode), mindist(dist) {}
 
-    static BranchStruct<T> make_branch(const T& aNode, float dist)
+    bool operator<(const BranchStruct<T, DistanceType>& rhs) const
     {
-        BranchStruct<T> branch;
-        branch.node = aNode;
-        branch.mindistsq = dist;
-        return branch;
+        return mindist<rhs.mindist;
     }
 };
 
 
-
-
-
-template <typename ELEM_TYPE>
+template <typename DistanceType>
 class ResultSet
 {
-protected:
-
 public:
+    virtual ~ResultSet() {}
 
-	virtual ~ResultSet() {};
+    virtual bool full() const = 0;
 
-	virtual void init(const ELEM_TYPE* target_, int veclen_) = 0;
+    virtual void addPoint(DistanceType dist, int index) = 0;
 
-	virtual int* getNeighbors() = 0;
-
-	virtual float* getDistances() = 0;
-
-	virtual size_t size() const = 0;
-
-	virtual bool full() const = 0;
-
-	virtual bool addPoint(const ELEM_TYPE* point, int index) = 0;
-
-	virtual float worstDist() const = 0;
+    virtual DistanceType worstDist() const = 0;
 
 };
 
-
-template <typename ELEM_TYPE>
-class KNNResultSet : public ResultSet<ELEM_TYPE>
+/**
+ * KNNSimpleResultSet does not ensure that the element it holds are unique.
+ * Is used in those cases where the nearest neighbour algorithm used does not
+ * attempt to insert the same element multiple times.
+ */
+template <typename DistanceType>
+class KNNSimpleResultSet : public ResultSet<DistanceType>
 {
-	const ELEM_TYPE* target;
-	const ELEM_TYPE* target_end;
-    int veclen;
-
-	int* indices;
-	float* dists;
+    int* indices;
+    DistanceType* dists;
     int capacity;
-
-	int count;
+    int count;
+    DistanceType worst_distance_;
 
 public:
-	KNNResultSet(int capacity_, ELEM_TYPE* target_ = NULL, int veclen_ = 0 ) :
-			target(target_), veclen(veclen_), capacity(capacity_), count(0)
-	{
-		target_end = target + veclen;
-
-        indices = new int[capacity_];
-        dists = new float[capacity_];
-	}
-
-	~KNNResultSet()
-	{
-		delete[] indices;
-		delete[] dists;
-	}
-
-	void init(const ELEM_TYPE* target_, int veclen_)
-	{
-        target = target_;
-        veclen = veclen_;
-        target_end = target + veclen;
-        count = 0;
-	}
-
-
-	int* getNeighbors()
-	{
-		return indices;
-	}
-
-    float* getDistances()
+    KNNSimpleResultSet(int capacity_) : capacity(capacity_), count(0)
     {
-        return dists;
+    }
+
+    void init(int* indices_, DistanceType* dists_)
+    {
+        indices = indices_;
+        dists = dists_;
+        count = 0;
+        worst_distance_ = (std::numeric_limits<DistanceType>::max)();
+        dists[capacity-1] = worst_distance_;
     }
 
     size_t size() const
     {
-    	return count;
+        return count;
     }
 
-	bool full() const
-	{
-		return count == capacity;
-	}
+    bool full() const
+    {
+        return count == capacity;
+    }
 
 
-	bool addPoint(const ELEM_TYPE* point, int index)
-	{
-		for (int i=0;i<count;++i) {
-			if (indices[i]==index) return false;
-		}
-		float dist = (float)flann_dist(target, target_end, point);
+    void addPoint(DistanceType dist, int index)
+    {
+        if (dist >= worst_distance_) return;
+        int i;
+        for (i=count; i>0; --i) {
+#ifdef FLANN_FIRST_MATCH
+            if ( (dists[i-1]>dist) || ((dist==dists[i-1])&&(indices[i-1]>index)) )
+#else
+            if (dists[i-1]>dist)
+#endif
+            {
+                if (i<capacity) {
+                    dists[i] = dists[i-1];
+                    indices[i] = indices[i-1];
+                }
+            }
+            else break;
+        }
+        if (count < capacity) ++count;
+        dists[i] = dist;
+        indices[i] = index;
+        worst_distance_ = dists[capacity-1];
+    }
 
-		if (count<capacity) {
-			indices[count] = index;
-			dists[count] = dist;
-			++count;
-		}
-		else if (dist < dists[count-1] || (dist == dists[count-1] && index < indices[count-1])) {
-//         else if (dist < dists[count-1]) {
-			indices[count-1] = index;
-			dists[count-1] = dist;
-		}
-		else {
-			return false;
-		}
+    DistanceType worstDist() const
+    {
+        return worst_distance_;
+    }
+};
 
-		int i = count-1;
-		// bubble up
-		while (i>=1 && (dists[i]<dists[i-1] || (dists[i]==dists[i-1] && indices[i]<indices[i-1]) ) ) {
-//         while (i>=1 && (dists[i]<dists[i-1]) ) {
-            std::swap(indices[i],indices[i-1]);
-            std::swap(dists[i],dists[i-1]);
-			i--;
-		}
+/**
+ * K-Nearest neighbour result set. Ensures that the elements inserted are unique
+ */
+template <typename DistanceType>
+class KNNResultSet : public ResultSet<DistanceType>
+{
+    int* indices;
+    DistanceType* dists;
+    int capacity;
+    int count;
+    DistanceType worst_distance_;
 
-		return true;
-	}
+public:
+    KNNResultSet(int capacity_) : capacity(capacity_), count(0)
+    {
+    }
 
-	float worstDist() const
-	{
-		return (count<capacity) ? (std::numeric_limits<float>::max)() : dists[count-1];
-	}
+    void init(int* indices_, DistanceType* dists_)
+    {
+        indices = indices_;
+        dists = dists_;
+        count = 0;
+        worst_distance_ = (std::numeric_limits<DistanceType>::max)();
+        dists[capacity-1] = worst_distance_;
+    }
+
+    size_t size() const
+    {
+        return count;
+    }
+
+    bool full() const
+    {
+        return count == capacity;
+    }
+
+
+    void addPoint(DistanceType dist, int index)
+    {
+        if (dist >= worst_distance_) return;
+        int i;
+        for (i = count; i > 0; --i) {
+#ifdef FLANN_FIRST_MATCH
+            if ( (dists[i-1]<=dist) && ((dist!=dists[i-1])||(indices[i-1]<=index)) )
+#else
+            if (dists[i-1]<=dist)
+#endif
+            {
+                // Check for duplicate indices
+                int j = i - 1;
+                while ((j >= 0) && (dists[j] == dist)) {
+                    if (indices[j] == index) {
+                        return;
+                    }
+                    --j;
+                }
+                break;
+            }
+        }
+
+        if (count < capacity) ++count;
+        for (int j = count-1; j > i; --j) {
+            dists[j] = dists[j-1];
+            indices[j] = indices[j-1];
+        }
+        dists[i] = dist;
+        indices[i] = index;
+        worst_distance_ = dists[capacity-1];
+    }
+
+    DistanceType worstDist() const
+    {
+        return worst_distance_;
+    }
 };
 
 
 /**
  * A result-set class used when performing a radius based search.
  */
-template <typename ELEM_TYPE>
-class RadiusResultSet : public ResultSet<ELEM_TYPE>
+template <typename DistanceType>
+class RadiusResultSet : public ResultSet<DistanceType>
 {
-	const ELEM_TYPE* target;
-	const ELEM_TYPE* target_end;
-    int veclen;
-
-	struct Item {
-		int index;
-		float dist;
-
-		bool operator<(Item rhs) {
-			return dist<rhs.dist;
-		}
-	};
-
-    std::vector<Item> items;
-	float radius;
-
-	bool sorted;
-	int* indices;
-	float* dists;
-	size_t count;
-
-private:
-	void resize_vecs()
-	{
-		if (items.size()>count) {
-			if (indices!=NULL) delete[] indices;
-			if (dists!=NULL) delete[] dists;
-			count = items.size();
-			indices = new int[count];
-			dists = new float[count];
-		}
-	}
+    DistanceType radius;
+    int* indices;
+    DistanceType* dists;
+    size_t capacity;
+    size_t count;
 
 public:
-	RadiusResultSet(float radius_) :
-		radius(radius_), indices(NULL), dists(NULL)
-	{
-		sorted = false;
-		items.reserve(16);
-		count = 0;
-	}
-
-	~RadiusResultSet()
-	{
-		if (indices!=NULL) delete[] indices;
-		if (dists!=NULL) delete[] dists;
-	}
-
-	void init(const ELEM_TYPE* target_, int veclen_)
-	{
-        target = target_;
-        veclen = veclen_;
-        target_end = target + veclen;
-        items.clear();
-        sorted = false;
-	}
-
-	int* getNeighbors()
-	{
-		if (!sorted) {
-			sorted = true;
-			sort_heap(items.begin(), items.end());
-		}
-		resize_vecs();
-		for (size_t i=0;i<items.size();++i) {
-			indices[i] = items[i].index;
-		}
-		return indices;
-	}
-
-    float* getDistances()
+    RadiusResultSet(DistanceType radius_, int* indices_, DistanceType* dists_, int capacity_) :
+        radius(radius_), indices(indices_), dists(dists_), capacity(capacity_)
     {
-		if (!sorted) {
-			sorted = true;
-			sort_heap(items.begin(), items.end());
-		}
-		resize_vecs();
-		for (size_t i=0;i<items.size();++i) {
-			dists[i] = items[i].dist;
-		}
-        return dists;
+        init();
+    }
+
+    ~RadiusResultSet()
+    {
+    }
+
+    void init()
+    {
+        count = 0;
     }
 
     size_t size() const
     {
-    	return items.size();
+        return count;
     }
 
-	bool full() const
-	{
-		return true;
-	}
+    bool full() const
+    {
+        return true;
+    }
 
-	bool addPoint(const ELEM_TYPE* point, int index)
-	{
-		Item it;
-		it.index = index;
-		it.dist = (float)flann_dist(target, target_end, point);
-		if (it.dist<=radius) {
-			items.push_back(it);
-			push_heap(items.begin(), items.end());
-            return true;
-		}
-        return false;
-	}
+    void addPoint(DistanceType dist, int index)
+    {
+        if (dist<radius) {
+            if ((capacity>0)&&(count < capacity)) {
+                dists[count] = dist;
+                indices[count] = index;
+            }
+            count++;
+        }
+    }
 
-	float worstDist() const
-	{
-		return radius;
-	}
+    DistanceType worstDist() const
+    {
+        return radius;
+    }
 
 };
 
-} // namespace cvflann
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Class that holds the k NN neighbors
+ * Faster than KNNResultSet as it uses a binary heap and does not maintain two arrays
+ */
+template<typename DistanceType>
+class UniqueResultSet : public ResultSet<DistanceType>
+{
+public:
+    struct DistIndex
+    {
+        DistIndex(DistanceType dist, unsigned int index) :
+            dist_(dist), index_(index)
+        {
+        }
+        bool operator<(const DistIndex dist_index) const
+        {
+            return (dist_ < dist_index.dist_) || ((dist_ == dist_index.dist_) && index_ < dist_index.index_);
+        }
+        DistanceType dist_;
+        unsigned int index_;
+    };
+
+    /** Default cosntructor */
+    UniqueResultSet() :
+        worst_distance_(std::numeric_limits<DistanceType>::max())
+    {
+    }
+
+    /** Check the status of the set
+     * @return true if we have k NN
+     */
+    inline bool full() const
+    {
+        return is_full_;
+    }
+
+    /** Remove all elements in the set
+     */
+    virtual void clear() = 0;
+
+    /** Copy the set to two C arrays
+     * @param indices pointer to a C array of indices
+     * @param dist pointer to a C array of distances
+     * @param n_neighbors the number of neighbors to copy
+     */
+    virtual void copy(int* indices, DistanceType* dist, int n_neighbors = -1) const
+    {
+        if (n_neighbors < 0) {
+            for (typename std::set<DistIndex>::const_iterator dist_index = dist_indices_.begin(), dist_index_end =
+                     dist_indices_.end(); dist_index != dist_index_end; ++dist_index, ++indices, ++dist) {
+                *indices = dist_index->index_;
+                *dist = dist_index->dist_;
+            }
+        }
+        else {
+            int i = 0;
+            for (typename std::set<DistIndex>::const_iterator dist_index = dist_indices_.begin(), dist_index_end =
+                     dist_indices_.end(); (dist_index != dist_index_end) && (i < n_neighbors); ++dist_index, ++indices, ++dist, ++i) {
+                *indices = dist_index->index_;
+                *dist = dist_index->dist_;
+            }
+        }
+    }
+
+    /** Copy the set to two C arrays but sort it according to the distance first
+     * @param indices pointer to a C array of indices
+     * @param dist pointer to a C array of distances
+     * @param n_neighbors the number of neighbors to copy
+     */
+    virtual void sortAndCopy(int* indices, DistanceType* dist, int n_neighbors = -1) const
+    {
+        copy(indices, dist, n_neighbors);
+    }
+
+    /** The number of neighbors in the set
+     * @return
+     */
+    size_t size() const
+    {
+        return dist_indices_.size();
+    }
+
+    /** The distance of the furthest neighbor
+     * If we don't have enough neighbors, it returns the max possible value
+     * @return
+     */
+    inline DistanceType worstDist() const
+    {
+        return worst_distance_;
+    }
+protected:
+    /** Flag to say if the set is full */
+    bool is_full_;
+
+    /** The worst distance found so far */
+    DistanceType worst_distance_;
+
+    /** The best candidates so far */
+    std::set<DistIndex> dist_indices_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Class that holds the k NN neighbors
+ * Faster than KNNResultSet as it uses a binary heap and does not maintain two arrays
+ */
+template<typename DistanceType>
+class KNNUniqueResultSet : public UniqueResultSet<DistanceType>
+{
+public:
+    /** Constructor
+     * @param capacity the number of neighbors to store at max
+     */
+    KNNUniqueResultSet(unsigned int capacity) : capacity_(capacity)
+    {
+        this->is_full_ = false;
+        this->clear();
+    }
+
+    /** Add a possible candidate to the best neighbors
+     * @param dist distance for that neighbor
+     * @param index index of that neighbor
+     */
+    inline void addPoint(DistanceType dist, int index)
+    {
+        // Don't do anything if we are worse than the worst
+        if (dist >= worst_distance_) return;
+        dist_indices_.insert(DistIndex(dist, index));
+
+        if (is_full_) {
+            if (dist_indices_.size() > capacity_) {
+                dist_indices_.erase(*dist_indices_.rbegin());
+                worst_distance_ = dist_indices_.rbegin()->dist_;
+            }
+        }
+        else if (dist_indices_.size() == capacity_) {
+            is_full_ = true;
+            worst_distance_ = dist_indices_.rbegin()->dist_;
+        }
+    }
+
+    /** Remove all elements in the set
+     */
+    void clear()
+    {
+        dist_indices_.clear();
+        worst_distance_ = std::numeric_limits<DistanceType>::max();
+        is_full_ = false;
+    }
+
+protected:
+    typedef typename UniqueResultSet<DistanceType>::DistIndex DistIndex;
+    using UniqueResultSet<DistanceType>::is_full_;
+    using UniqueResultSet<DistanceType>::worst_distance_;
+    using UniqueResultSet<DistanceType>::dist_indices_;
+
+    /** The number of neighbors to keep */
+    unsigned int capacity_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Class that holds the radius nearest neighbors
+ * It is more accurate than RadiusResult as it is not limited in the number of neighbors
+ */
+template<typename DistanceType>
+class RadiusUniqueResultSet : public UniqueResultSet<DistanceType>
+{
+public:
+    /** Constructor
+     * @param capacity the number of neighbors to store at max
+     */
+    RadiusUniqueResultSet(DistanceType radius) :
+        radius_(radius)
+    {
+        is_full_ = true;
+    }
+
+    /** Add a possible candidate to the best neighbors
+     * @param dist distance for that neighbor
+     * @param index index of that neighbor
+     */
+    void addPoint(DistanceType dist, int index)
+    {
+        if (dist <= radius_) dist_indices_.insert(DistIndex(dist, index));
+    }
+
+    /** Remove all elements in the set
+     */
+    inline void clear()
+    {
+        dist_indices_.clear();
+    }
+
+
+    /** Check the status of the set
+     * @return alwys false
+     */
+    inline bool full() const
+    {
+        return true;
+    }
+
+    /** The distance of the furthest neighbor
+     * If we don't have enough neighbors, it returns the max possible value
+     * @return
+     */
+    inline DistanceType worstDist() const
+    {
+        return radius_;
+    }
+private:
+    typedef typename UniqueResultSet<DistanceType>::DistIndex DistIndex;
+    using UniqueResultSet<DistanceType>::dist_indices_;
+    using UniqueResultSet<DistanceType>::is_full_;
+
+    /** The furthest distance a neighbor can be */
+    DistanceType radius_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/** Class that holds the k NN neighbors within a radius distance
+ */
+template<typename DistanceType>
+class KNNRadiusUniqueResultSet : public KNNUniqueResultSet<DistanceType>
+{
+public:
+    /** Constructor
+     * @param capacity the number of neighbors to store at max
+     */
+    KNNRadiusUniqueResultSet(unsigned int capacity, DistanceType radius)
+    {
+        this->capacity_ = capacity;
+        this->radius_ = radius;
+        this->dist_indices_.reserve(capacity_);
+        this->clear();
+    }
+
+    /** Remove all elements in the set
+     */
+    void clear()
+    {
+        dist_indices_.clear();
+        worst_distance_ = radius_;
+        is_full_ = false;
+    }
+private:
+    using KNNUniqueResultSet<DistanceType>::dist_indices_;
+    using KNNUniqueResultSet<DistanceType>::is_full_;
+    using KNNUniqueResultSet<DistanceType>::worst_distance_;
+
+    /** The maximum number of neighbors to consider */
+    unsigned int capacity_;
+
+    /** The maximum distance of a neighbor */
+    DistanceType radius_;
+};
+}
+
+#endif //FLANN_RESULTSET_H
 
-#endif //_OPENCV_RESULTSET_H_
diff --git a/modules/flann/include/opencv2/flann/sampling.h b/modules/flann/include/opencv2/flann/sampling.h
index 95f6e150ce..fd651505a0 100644
--- a/modules/flann/include/opencv2/flann/sampling.h
+++ b/modules/flann/include/opencv2/flann/sampling.h
@@ -27,13 +27,11 @@
  *************************************************************************/
 
 
-#ifndef _OPENCV_SAMPLING_H_
-#define _OPENCV_SAMPLING_H_
-
-
-#include "opencv2/flann/matrix.h"
-#include "opencv2/flann/random.h"
+#ifndef OPENCV_FLANN_SAMPLING_H_
+#define OPENCV_FLANN_SAMPLING_H_
 
+#include "matrix.h"
+#include "random.h"
 
 namespace cvflann
 {
@@ -41,54 +39,43 @@ namespace cvflann
 template<typename T>
 Matrix<T> random_sample(Matrix<T>& srcMatrix, long size, bool remove = false)
 {
-    UniqueRandom rand((int)srcMatrix.rows);
-    Matrix<T> newSet(new T[size * srcMatrix.cols], size, (long)srcMatrix.cols);
+    Matrix<T> newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols);
 
-    T *src,*dest;
-    for (long i=0;i<size;++i) {
-        long r = rand.next();
+    T* src,* dest;
+    for (long i=0; i<size; ++i) {
+        long r = rand_int(srcMatrix.rows-i);
         dest = newSet[i];
         src = srcMatrix[r];
-        for (size_t j=0;j<srcMatrix.cols;++j) {
-            dest[j] = src[j];
-        }
+        std::copy(src, src+srcMatrix.cols, dest);
         if (remove) {
-            dest = srcMatrix[srcMatrix.rows-i-1];
-            src = srcMatrix[r];
-            for (size_t j=0;j<srcMatrix.cols;++j) {
-                std::swap(*src,*dest);
-                src++;
-                dest++;
-            }
+            src = srcMatrix[srcMatrix.rows-i-1];
+            dest = srcMatrix[r];
+            std::copy(src, src+srcMatrix.cols, dest);
         }
     }
-
     if (remove) {
-    	srcMatrix.rows -= size;
+        srcMatrix.rows -= size;
     }
-
     return newSet;
 }
 
 template<typename T>
 Matrix<T> random_sample(const Matrix<T>& srcMatrix, size_t size)
 {
-    UniqueRandom rand((int)srcMatrix.rows);
-    Matrix<T> newSet(new T[size * srcMatrix.cols], (long)size, (long)srcMatrix.cols);
+    UniqueRandom rand(srcMatrix.rows);
+    Matrix<T> newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols);
 
-    T *src,*dest;
-    for (size_t i=0;i<size;++i) {
+    T* src,* dest;
+    for (size_t i=0; i<size; ++i) {
         long r = rand.next();
         dest = newSet[i];
         src = srcMatrix[r];
-        for (size_t j=0;j<srcMatrix.cols;++j) {
-            dest[j] = src[j];
-        }
+        std::copy(src, src+srcMatrix.cols, dest);
     }
-
     return newSet;
 }
 
-} // namespace cvflann
+} // namespace
 
-#endif /* _OPENCV_SAMPLING_H_ */
+
+#endif /* OPENCV_FLANN_SAMPLING_H_ */
diff --git a/modules/flann/include/opencv2/flann/saving.h b/modules/flann/include/opencv2/flann/saving.h
index 52116ec96d..7e3bea564b 100644
--- a/modules/flann/include/opencv2/flann/saving.h
+++ b/modules/flann/include/opencv2/flann/saving.h
@@ -26,41 +26,54 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_SAVING_H_
-#define _OPENCV_SAVING_H_
+#ifndef OPENCV_FLANN_SAVING_H_
+#define OPENCV_FLANN_SAVING_H_
 
-#include "opencv2/flann/general.h"
-#include "opencv2/flann/nn_index.h"
-#include <cstdio>
 #include <cstring>
+#include <vector>
+
+#include "general.h"
+#include "nn_index.h"
+
+#ifdef FLANN_SIGNATURE_
+#undef FLANN_SIGNATURE_
+#endif
+#define FLANN_SIGNATURE_ "FLANN_INDEX"
 
 namespace cvflann
 {
-template <typename T> struct Datatype {};
-template<> struct Datatype<char> { static flann_datatype_t type() { return FLANN_INT8; } };
-template<> struct Datatype<short> { static flann_datatype_t type() { return FLANN_INT16; } };
-template<> struct Datatype<int> { static flann_datatype_t type() { return FLANN_INT32; } };
-template<> struct Datatype<unsigned char> { static flann_datatype_t type() { return FLANN_UINT8; } };
-template<> struct Datatype<unsigned short> { static flann_datatype_t type() { return FLANN_UINT16; } };
-template<> struct Datatype<unsigned int> { static flann_datatype_t type() { return FLANN_UINT32; } };
-template<> struct Datatype<float> { static flann_datatype_t type() { return FLANN_FLOAT32; } };
-template<> struct Datatype<double> { static flann_datatype_t type() { return FLANN_FLOAT64; } };
 
+template <typename T>
+struct Datatype {};
+template<>
+struct Datatype<char> { static flann_datatype_t type() { return FLANN_INT8; } };
+template<>
+struct Datatype<short> { static flann_datatype_t type() { return FLANN_INT16; } };
+template<>
+struct Datatype<int> { static flann_datatype_t type() { return FLANN_INT32; } };
+template<>
+struct Datatype<unsigned char> { static flann_datatype_t type() { return FLANN_UINT8; } };
+template<>
+struct Datatype<unsigned short> { static flann_datatype_t type() { return FLANN_UINT16; } };
+template<>
+struct Datatype<unsigned int> { static flann_datatype_t type() { return FLANN_UINT32; } };
+template<>
+struct Datatype<float> { static flann_datatype_t type() { return FLANN_FLOAT32; } };
+template<>
+struct Datatype<double> { static flann_datatype_t type() { return FLANN_FLOAT64; } };
 
-CV_EXPORTS const char* FLANN_SIGNATURE();
-CV_EXPORTS const char* FLANN_VERSION();
 
 /**
  * Structure representing the index header.
  */
-struct CV_EXPORTS IndexHeader
+struct IndexHeader
 {
-	char signature[16];
-	char version[16];
-	flann_datatype_t data_type;
-	flann_algorithm_t index_type;
-	int rows;
-	int cols;
+    char signature[16];
+    char version[16];
+    flann_datatype_t data_type;
+    flann_algorithm_t index_type;
+    size_t rows;
+    size_t cols;
 };
 
 /**
@@ -69,20 +82,20 @@ struct CV_EXPORTS IndexHeader
  * @param stream - Stream to save to
  * @param index - The index to save
  */
-template<typename ELEM_TYPE>
-void save_header(FILE* stream, const NNIndex<ELEM_TYPE>& index)
+template<typename Distance>
+void save_header(FILE* stream, const NNIndex<Distance>& index)
 {
-	IndexHeader header;
-	memset(header.signature, 0 , sizeof(header.signature));
-	strcpy(header.signature, FLANN_SIGNATURE());
-	memset(header.version, 0 , sizeof(header.version));
-	strcpy(header.version, FLANN_VERSION());
-	header.data_type = Datatype<ELEM_TYPE>::type();
-	header.index_type = index.getType();
-	header.rows = (int)index.size();
-	header.cols = index.veclen();
+    IndexHeader header;
+    memset(header.signature, 0, sizeof(header.signature));
+    strcpy(header.signature, FLANN_SIGNATURE_);
+    memset(header.version, 0, sizeof(header.version));
+    strcpy(header.version, FLANN_VERSION_);
+    header.data_type = Datatype<typename Distance::ElementType>::type();
+    header.index_type = index.getType();
+    header.rows = index.size();
+    header.cols = index.veclen();
 
-	std::fwrite(&header, sizeof(header),1,stream);
+    std::fwrite(&header, sizeof(header),1,stream);
 }
 
 
@@ -91,25 +104,84 @@ void save_header(FILE* stream, const NNIndex<ELEM_TYPE>& index)
  * @param stream - Stream to load from
  * @return Index header
  */
-CV_EXPORTS IndexHeader load_header(FILE* stream);
-
-
-template<typename T>
-void save_value(FILE* stream, const T& value, int count = 1)
+inline IndexHeader load_header(FILE* stream)
 {
-	fwrite(&value, 1, sizeof(value)*count, stream);
+    IndexHeader header;
+    size_t read_size = fread(&header,sizeof(header),1,stream);
+
+    if (read_size!=(size_t)1) {
+        throw FLANNException("Invalid index file, cannot read");
+    }
+
+    if (strcmp(header.signature,FLANN_SIGNATURE_)!=0) {
+        throw FLANNException("Invalid index file, wrong signature");
+    }
+
+    return header;
+
 }
 
 
 template<typename T>
-void load_value(FILE* stream, T& value, int count = 1)
+void save_value(FILE* stream, const T& value, size_t count = 1)
 {
-	int read_cnt = (int)fread(&value, sizeof(value),count, stream);
-	if (read_cnt!=count) {
-		throw FLANNException("Cannot read from file");
-	}
+    fwrite(&value, sizeof(value),count, stream);
 }
 
-} // namespace cvflann
+template<typename T>
+void save_value(FILE* stream, const cvflann::Matrix<T>& value)
+{
+    fwrite(&value, sizeof(value),1, stream);
+    fwrite(value.data, sizeof(T),value.rows*value.cols, stream);
+}
 
-#endif /* _OPENCV_SAVING_H_ */
+template<typename T>
+void save_value(FILE* stream, const std::vector<T>& value)
+{
+    size_t size = value.size();
+    fwrite(&size, sizeof(size_t), 1, stream);
+    fwrite(&value[0], sizeof(T), size, stream);
+}
+
+template<typename T>
+void load_value(FILE* stream, T& value, size_t count = 1)
+{
+    size_t read_cnt = fread(&value, sizeof(value), count, stream);
+    if (read_cnt != count) {
+        throw FLANNException("Cannot read from file");
+    }
+}
+
+template<typename T>
+void load_value(FILE* stream, cvflann::Matrix<T>& value)
+{
+    size_t read_cnt = fread(&value, sizeof(value), 1, stream);
+    if (read_cnt != 1) {
+        throw FLANNException("Cannot read from file");
+    }
+    value.data = new T[value.rows*value.cols];
+    read_cnt = fread(value.data, sizeof(T), value.rows*value.cols, stream);
+    if (read_cnt != (size_t)(value.rows*value.cols)) {
+        throw FLANNException("Cannot read from file");
+    }
+}
+
+
+template<typename T>
+void load_value(FILE* stream, std::vector<T>& value)
+{
+    size_t size;
+    size_t read_cnt = fread(&size, sizeof(size_t), 1, stream);
+    if (read_cnt!=1) {
+        throw FLANNException("Cannot read from file");
+    }
+    value.resize(size);
+    read_cnt = fread(&value[0], sizeof(T), size, stream);
+    if (read_cnt != size) {
+        throw FLANNException("Cannot read from file");
+    }
+}
+
+}
+
+#endif /* OPENCV_FLANN_SAVING_H_ */
diff --git a/modules/flann/include/opencv2/flann/simplex_downhill.h b/modules/flann/include/opencv2/flann/simplex_downhill.h
index 21d3e944b1..145901ab0d 100644
--- a/modules/flann/include/opencv2/flann/simplex_downhill.h
+++ b/modules/flann/include/opencv2/flann/simplex_downhill.h
@@ -28,20 +28,20 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_SIMPLEX_DOWNHILL_H_
-#define _OPENCV_SIMPLEX_DOWNHILL_H_
+#ifndef OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
+#define OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
 
 namespace cvflann
 {
 
 /**
     Adds val to array vals (and point to array points) and keeping the arrays sorted by vals.
-*/
+ */
 template <typename T>
 void addValue(int pos, float val, float* vals, T* point, T* points, int n)
 {
     vals[pos] = val;
-    for (int i=0;i<n;++i) {
+    for (int i=0; i<n; ++i) {
         points[pos*n+i] = point[i];
     }
 
@@ -49,7 +49,7 @@ void addValue(int pos, float val, float* vals, T* point, T* points, int n)
     int j=pos;
     while (j>0 && vals[j]<vals[j-1]) {
         swap(vals[j],vals[j-1]);
-        for (int i=0;i<n;++i) {
+        for (int i=0; i<n; ++i) {
             swap(points[j*n+i],points[(j-1)*n+i]);
         }
         --j;
@@ -64,7 +64,7 @@ void addValue(int pos, float val, float* vals, T* point, T* points, int n)
                     vals is the cost function in the n+1 simplex points, if NULL it will be computed
 
     Postcondition: returns optimum value and points[0..n] are the optimum parameters
-*/
+ */
 template <typename T, typename F>
 float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
 {
@@ -84,7 +84,7 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
     if (vals == NULL) {
         ownVals = true;
         vals = new float[n+1];
-        for (int i=0;i<n+1;++i) {
+        for (int i=0; i<n+1; ++i) {
             float val = func(points+i*n);
             addValue(i, val, vals, points+i*n, points, n);
         }
@@ -96,18 +96,18 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
         if (iterations++ > MAX_ITERATIONS) break;
 
         // compute average of simplex points (except the highest point)
-        for (int j=0;j<n;++j) {
+        for (int j=0; j<n; ++j) {
             p_o[j] = 0;
-            for (int i=0;i<n;++i) {
+            for (int i=0; i<n; ++i) {
                 p_o[i] += points[j*n+i];
             }
         }
-        for (int i=0;i<n;++i) {
+        for (int i=0; i<n; ++i) {
             p_o[i] /= n;
         }
 
         bool converged = true;
-        for (int i=0;i<n;++i) {
+        for (int i=0; i<n; ++i) {
             if (p_o[i] != points[nn+i]) {
                 converged = false;
             }
@@ -115,15 +115,15 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
         if (converged) break;
 
         // trying a reflection
-        for (int i=0;i<n;++i) {
+        for (int i=0; i<n; ++i) {
             p_r[i] = p_o[i] + alpha*(p_o[i]-points[nn+i]);
         }
         float val_r = func(p_r);
 
-        if (val_r>=vals[0] && val_r<vals[n]) {
+        if ((val_r>=vals[0])&&(val_r<vals[n])) {
             // reflection between second highest and lowest
             // add it to the simplex
-            logger().info("Choosing reflection\n");
+            Logger::info("Choosing reflection\n");
             addValue(n, val_r,vals, p_r, points, n);
             continue;
         }
@@ -132,37 +132,37 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
             // value is smaller than smalest in simplex
 
             // expand some more to see if it drops further
-            for (int i=0;i<n;++i) {
+            for (int i=0; i<n; ++i) {
                 p_e[i] = 2*p_r[i]-p_o[i];
             }
             float val_e = func(p_e);
 
             if (val_e<val_r) {
-                logger().info("Choosing reflection and expansion\n");
+                Logger::info("Choosing reflection and expansion\n");
                 addValue(n, val_e,vals,p_e,points,n);
             }
             else {
-                logger().info("Choosing reflection\n");
+                Logger::info("Choosing reflection\n");
                 addValue(n, val_r,vals,p_r,points,n);
             }
             continue;
         }
         if (val_r>=vals[n]) {
-            for (int i=0;i<n;++i) {
+            for (int i=0; i<n; ++i) {
                 p_e[i] = (p_o[i]+points[nn+i])/2;
             }
             float val_e = func(p_e);
 
             if (val_e<vals[n]) {
-                logger().info("Choosing contraction\n");
+                Logger::info("Choosing contraction\n");
                 addValue(n,val_e,vals,p_e,points,n);
                 continue;
             }
         }
         {
-          logger().info("Full contraction\n");
-            for (int j=1;j<=n;++j) {
-                for (int i=0;i<n;++i) {
+            Logger::info("Full contraction\n");
+            for (int j=1; j<=n; ++j) {
+                for (int i=0; i<n; ++i) {
                     points[j*n+i] = (points[j*n+i]+points[i])/2;
                 }
                 float val = func(points+j*n);
@@ -181,6 +181,6 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL )
     return bestVal;
 }
 
-} // namespace cvflann
+}
 
-#endif //_OPENCV_SIMPLEX_DOWNHILL_H_
+#endif //OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
diff --git a/modules/flann/include/opencv2/flann/timer.h b/modules/flann/include/opencv2/flann/timer.h
index db320572b2..a06c5c018c 100644
--- a/modules/flann/include/opencv2/flann/timer.h
+++ b/modules/flann/include/opencv2/flann/timer.h
@@ -28,8 +28,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *************************************************************************/
 
-#ifndef _OPENCV_TIMER_H_
-#define _OPENCV_TIMER_H_
+#ifndef FLANN_TIMER_H
+#define FLANN_TIMER_H
 
 #include <time.h>
 
@@ -42,7 +42,7 @@ namespace cvflann
  *
  * Can be used to time portions of code.
  */
-class CV_EXPORTS StartStopTimer
+class StartStopTimer
 {
     clock_t startTime;
 
@@ -64,14 +64,16 @@ public:
     /**
      * Starts the timer.
      */
-    void start() {
+    void start()
+    {
         startTime = clock();
     }
 
     /**
      * Stops the timer and updates timer value.
      */
-    void stop() {
+    void stop()
+    {
         clock_t stopTime = clock();
         value += ( (double)stopTime - startTime) / CLOCKS_PER_SEC;
     }
@@ -79,12 +81,13 @@ public:
     /**
      * Resets the timer value to 0.
      */
-    void reset() {
+    void reset()
+    {
         value = 0;
     }
 
 };
 
-}// namespace cvflann
+}
 
-#endif // _OPENCV_TIMER_H_
+#endif // FLANN_TIMER_H
diff --git a/modules/flann/src/flann.cpp b/modules/flann/src/flann.cpp
index 30a82ea6f4..36ee6694a3 100644
--- a/modules/flann/src/flann.cpp
+++ b/modules/flann/src/flann.cpp
@@ -27,199 +27,31 @@
  *************************************************************************/
 
 #include "precomp.hpp"
+#include "opencv2/flann/flann.hpp"
 
 namespace cvflann
 {
-// ----------------------- dist.cpp ---------------------------
-
-/** Global variable indicating the distance metric
- * to be used.
- */
-flann_distance_t flann_distance_type_ = FLANN_DIST_EUCLIDEAN;
-flann_distance_t flann_distance_type() { return flann_distance_type_; }
-
-/**
- * Zero iterator that emulates a zero feature.
- */
-ZeroIterator<float> zero_;
-ZeroIterator<float>& zero() { return zero_; }
-
-/**
- * Order of Minkowski distance to use.
- */
-int flann_minkowski_order_;
-int flann_minkowski_order() { return flann_minkowski_order_; }
-
-
-double euclidean_dist(const unsigned char* first1, const unsigned char* last1, unsigned char* first2, double acc)
-{
-	double distsq = acc;
-	double diff0, diff1, diff2, diff3;
-	const unsigned char* lastgroup = last1 - 3;
-
-	while (first1 < lastgroup) {
-		diff0 = first1[0] - first2[0];
-		diff1 = first1[1] - first2[1];
-		diff2 = first1[2] - first2[2];
-		diff3 = first1[3] - first2[3];
-		distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
-		first1 += 4;
-		first2 += 4;
-	}
-	while (first1 < last1) {
-		diff0 = *first1++ - *first2++;
-		distsq += diff0 * diff0;
-	}
-	return distsq;
-}
-
-// ----------------------- index_testing.cpp ---------------------------
-
-int countCorrectMatches(int* neighbors, int* groundTruth, int n)
-{
-    int count = 0;
-    for (int i=0;i<n;++i) {
-        for (int k=0;k<n;++k) {
-            if (neighbors[i]==groundTruth[k]) {
-                count++;
-                break;
-            }
+    /** Global variable indicating the distance metric to be used.
+     * \deprecated Provided for backward compatibility
+    */
+    flann_distance_t flann_distance_type_ = FLANN_DIST_L2;
+    flann_distance_t flann_distance_type() { return flann_distance_type_; }
+    
+    /**
+     * Set distance type to used
+     * \deprecated
+     */
+    void set_distance_type(flann_distance_t distance_type, int /*order*/)
+    {
+        printf("[WARNING] The cvflann::set_distance_type function is deperecated, "
+            "use cv::flann::GenericIndex<Distance> instead.\n");
+        if (distance_type != FLANN_DIST_L1 && distance_type != FLANN_DIST_L2) {
+            printf("[ERROR] cvflann::set_distance_type only provides backwards compatibility "
+            "for the L1 and L2 distances. "
+            "For other distance types you must use cv::flann::GenericIndex<Distance>\n");
         }
+        flann_distance_type_ = distance_type;
     }
-    return count;
-}
-
-// ----------------------- logger.cpp ---------------------------
-
-Logger logger_;
-
-Logger& logger() { return logger_; }
-
-int Logger::log(int level, const char* fmt, ...)
-{
-    if (level > logLevel ) return -1;
-
-    int ret;
-    va_list arglist;
-    va_start(arglist, fmt);
-    ret = vfprintf(stream, fmt, arglist);
-    va_end(arglist);
-
-    return ret;
-}
-
-int Logger::log(int level, const char* fmt, va_list arglist)
-{
-    if (level > logLevel ) return -1;
-
-    int ret;
-    ret = vfprintf(stream, fmt, arglist);
-
-    return ret;
-}
-
-
-#define LOG_METHOD(NAME,LEVEL) \
-    int Logger::NAME(const char* fmt, ...) \
-    { \
-        int ret; \
-        va_list ap; \
-        va_start(ap, fmt); \
-        ret = log(LEVEL, fmt, ap); \
-        va_end(ap); \
-        return ret; \
-    }
-
-
-LOG_METHOD(fatal, FLANN_LOG_FATAL)
-LOG_METHOD(error, FLANN_LOG_ERROR)
-LOG_METHOD(warn, FLANN_LOG_WARN)
-LOG_METHOD(info, FLANN_LOG_INFO)
-
-// ----------------------- random.cpp ---------------------------
-
-void seed_random(unsigned int seed)
-{
-    srand(seed);
-}
-
-double rand_double(double high, double low)
-{
-    return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0)));
-}
-
-
-int rand_int(int high, int low)
-{
-    return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0)));
-}
-
-// ----------------------- saving.cpp ---------------------------
-
-const char FLANN_SIGNATURE_[] = "FLANN_INDEX";
-const char FLANN_VERSION_[] = "1.5.0";
-
-const char* FLANN_SIGNATURE() { return FLANN_SIGNATURE_; }
-const char* FLANN_VERSION() { return FLANN_VERSION_; }
-
-IndexHeader load_header(FILE* stream)
-{
-	IndexHeader header;
-	size_t read_size = fread(&header,sizeof(header),1,stream);
-
-	if (read_size!=1) {
-		throw FLANNException("Invalid index file, cannot read");
-	}
-
-	if (strcmp(header.signature,FLANN_SIGNATURE())!=0) {
-		throw FLANNException("Invalid index file, wrong signature");
-	}
-
-	return header;
-
-}
-
-// ----------------------- flann.cpp ---------------------------
-
-
-void log_verbosity(int level)
-{
-    if (level>=0) {
-        logger().setLevel(level);
-    }
-}
-
-void set_distance_type(flann_distance_t distance_type, int order)
-{
-	flann_distance_type_ = distance_type;
-	flann_minkowski_order_ = order;
-}
-
-
-static ParamsFactory the_factory;
-
-ParamsFactory& ParamsFactory_instance()
-{
-    return the_factory;
-}
-
-class StaticInit
-{
-public:
-	StaticInit()
-	{
-		ParamsFactory_instance().register_<LinearIndexParams>(FLANN_INDEX_LINEAR);
-		ParamsFactory_instance().register_<KDTreeIndexParams>(FLANN_INDEX_KDTREE);
-		ParamsFactory_instance().register_<KMeansIndexParams>(FLANN_INDEX_KMEANS);
-		ParamsFactory_instance().register_<CompositeIndexParams>(FLANN_INDEX_COMPOSITE);
-		ParamsFactory_instance().register_<AutotunedIndexParams>(FLANN_INDEX_AUTOTUNED);
-//		ParamsFactory::instance().register_<SavedIndexParams>(FLANN_INDEX_SAVED);
-	}
-};
-StaticInit __init;
-
-
-} // namespace cvflann
-
-
-
+    
+    void dummyfunc() {}
+}
\ No newline at end of file
diff --git a/modules/flann/src/miniflann.cpp b/modules/flann/src/miniflann.cpp
new file mode 100644
index 0000000000..54f3c9faac
--- /dev/null
+++ b/modules/flann/src/miniflann.cpp
@@ -0,0 +1,787 @@
+#include "precomp.hpp"
+
+#define MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES 0
+
+static cvflann::IndexParams& get_params(const cv::flann::IndexParams& p)
+{
+    return *(cvflann::IndexParams*)(p.params);
+}
+
+namespace cv
+{
+    
+namespace flann
+{
+
+IndexParams::IndexParams()
+{
+    params = new ::cvflann::IndexParams();
+}
+    
+IndexParams::~IndexParams()
+{
+    delete &get_params(*this);
+}
+
+template<typename T>
+T getParam(const IndexParams& _p, const std::string& key, const T& defaultVal=T())
+{
+    ::cvflann::IndexParams& p = get_params(_p);
+    ::cvflann::IndexParams::const_iterator it = p.find(key);
+    if( it == p.end() )
+        return defaultVal;
+    return it->second.cast<T>();
+}
+
+template<typename T>
+void setParam(IndexParams& _p, const std::string& key, const T& value)
+{
+    ::cvflann::IndexParams& p = get_params(_p);
+    p[key] = value;
+}    
+    
+std::string IndexParams::getString(const std::string& key, const std::string& defaultVal) const
+{
+    return getParam(*this, key, defaultVal);
+}
+    
+int IndexParams::getInt(const std::string& key, int defaultVal) const
+{
+    return getParam(*this, key, defaultVal);
+}
+    
+double IndexParams::getDouble(const std::string& key, double defaultVal) const
+{
+    return getParam(*this, key, defaultVal);
+}
+
+    
+void IndexParams::setString(const std::string& key, const std::string& value)
+{
+    setParam(*this, key, value);
+}
+
+void IndexParams::setInt(const std::string& key, int value)
+{
+    setParam(*this, key, value);
+}
+
+void IndexParams::setDouble(const std::string& key, double value)
+{
+    setParam(*this, key, value);
+}
+
+void IndexParams::setFloat(const std::string& key, float value)
+{
+    setParam(*this, key, value);
+}
+
+void IndexParams::setBool(const std::string& key, bool value)
+{
+    setParam(*this, key, value);
+}
+
+void IndexParams::setAlgorithm(const std::string& key, int value)
+{
+    setParam(*this, key, (cvflann::flann_algorithm_t)value);
+}
+    
+void IndexParams::getAll(std::vector<std::string>& names,
+            std::vector<int>& types,
+            std::vector<std::string>& strValues,
+            std::vector<double>& numValues) const
+{
+    names.clear();
+    types.clear();
+    strValues.clear();
+    numValues.clear();
+    
+    ::cvflann::IndexParams& p = get_params(*this);
+    ::cvflann::IndexParams::const_iterator it = p.begin(), it_end = p.end();
+    
+    for( ; it != it_end; ++it )
+    {
+        names.push_back(it->first);
+        try
+        {
+            std::string val = it->second.cast<std::string>();
+            types.push_back(CV_USRTYPE1);
+            strValues.push_back(val);
+            numValues.push_back(-1);
+	    continue;
+        }
+        catch (...) {}
+        
+        strValues.push_back(it->second.type().name());
+        
+        try
+        {
+            double val = it->second.cast<double>();
+            types.push_back( CV_64F );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            float val = it->second.cast<float>();
+            types.push_back( CV_32F );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            int val = it->second.cast<int>();
+            types.push_back( CV_32S );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            short val = it->second.cast<short>();
+            types.push_back( CV_16S );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            ushort val = it->second.cast<ushort>();
+            types.push_back( CV_16U );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            char val = it->second.cast<char>();
+            types.push_back( CV_8S );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            uchar val = it->second.cast<uchar>();
+            types.push_back( CV_8U );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            bool val = it->second.cast<bool>();
+            types.push_back( CV_MAKETYPE(CV_USRTYPE1,2) );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+        try
+        {
+            cvflann::flann_algorithm_t val = it->second.cast<cvflann::flann_algorithm_t>();
+            types.push_back( CV_MAKETYPE(CV_USRTYPE1,3) );
+            numValues.push_back(val);
+	    continue;
+        }
+        catch (...) {}
+
+
+        types.push_back(-1); // unknown type
+        numValues.push_back(-1);
+    }
+}
+    
+    
+KDTreeIndexParams::KDTreeIndexParams(int trees)
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_KDTREE;
+    p["trees"] = trees;
+}
+
+LinearIndexParams::LinearIndexParams()
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_LINEAR;
+}
+
+CompositeIndexParams::CompositeIndexParams(int trees, int branching, int iterations,
+                             flann_centers_init_t centers_init, float cb_index )
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_KMEANS;
+    // number of randomized trees to use (for kdtree)
+    p["trees"] = trees;
+    // branching factor
+    p["branching"] = branching;
+    // max iterations to perform in one kmeans clustering (kmeans tree)
+    p["iterations"] = iterations;
+    // algorithm used for picking the initial cluster centers for kmeans tree
+    p["centers_init"] = centers_init;
+    // cluster boundary index. Used when searching the kmeans tree
+    p["cb_index"] = cb_index;
+}
+    
+AutotunedIndexParams::AutotunedIndexParams(float target_precision, float build_weight,
+                                           float memory_weight, float sample_fraction)
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_AUTOTUNED;
+    // precision desired (used for autotuning, -1 otherwise)
+    p["target_precision"] = target_precision;
+    // build tree time weighting factor
+    p["build_weight"] = build_weight;
+    // index memory weighting factor
+    p["memory_weight"] = memory_weight;
+    // what fraction of the dataset to use for autotuning
+    p["sample_fraction"] = sample_fraction;
+}
+    
+
+KMeansIndexParams::KMeansIndexParams(int branching, int iterations,
+                  flann_centers_init_t centers_init, float cb_index )
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_KMEANS;
+    // branching factor
+    p["branching"] = branching;
+    // max iterations to perform in one kmeans clustering (kmeans tree)
+    p["iterations"] = iterations;
+    // algorithm used for picking the initial cluster centers for kmeans tree
+    p["centers_init"] = centers_init;
+    // cluster boundary index. Used when searching the kmeans tree
+    p["cb_index"] = cb_index;
+}
+    
+LshIndexParams::LshIndexParams(int table_number, int key_size, int multi_probe_level)
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    p["algorithm"] = FLANN_INDEX_LSH;
+    // The number of hash tables to use
+    p["table_number"] = (unsigned)table_number;
+    // The length of the key in the hash tables
+    p["key_size"] = (unsigned)key_size;
+    // Number of levels to use in multi-probe (0 for standard LSH)
+    p["multi_probe_level"] = (unsigned)multi_probe_level;
+}    
+    
+SavedIndexParams::SavedIndexParams(const std::string& _filename)
+{
+    std::string filename = _filename;
+    ::cvflann::IndexParams& p = get_params(*this);
+    
+    p["algorithm"] = FLANN_INDEX_SAVED;
+    p["filename"] = filename;
+}
+    
+SearchParams::SearchParams( int checks, float eps, bool sorted )
+{
+    ::cvflann::IndexParams& p = get_params(*this);
+    
+    // how many leafs to visit when searching for neighbours (-1 for unlimited)
+    p["checks"] = checks;
+    // search for eps-approximate neighbours (default: 0)
+    p["eps"] = eps;
+    // only for radius search, require neighbours sorted by distance (default: true)
+    p["sorted"] = sorted;
+}    
+
+    
+template<typename Distance, typename IndexType> void
+buildIndex_(void*& index, const Mat& data, const IndexParams& params, const Distance& dist = Distance())
+{
+    typedef typename Distance::ElementType ElementType;
+    CV_Assert(DataType<ElementType>::type == data.type() && data.isContinuous());
+    
+    ::cvflann::Matrix<ElementType> dataset((ElementType*)data.data, data.rows, data.cols);
+    IndexType* _index = new IndexType(dataset, get_params(params), dist);
+    _index->buildIndex();
+    index = _index;
+}
+
+template<typename Distance> void
+buildIndex(void*& index, const Mat& data, const IndexParams& params, const Distance& dist = Distance())
+{
+    buildIndex_<Distance, ::cvflann::Index<Distance> >(index, data, params, dist);
+}
+
+typedef ::cvflann::HammingLUT HammingDistance;
+typedef ::cvflann::LshIndex<HammingDistance> LshIndex;
+
+Index::Index()
+{
+    index = 0;
+    featureType = CV_32F;
+    algo = FLANN_INDEX_LINEAR;
+    distType = FLANN_DIST_L2;
+}
+    
+Index::Index(InputArray _data, const IndexParams& params, flann_distance_t _distType)
+{
+    index = 0;
+    featureType = CV_32F;
+    algo = FLANN_INDEX_LINEAR;
+    distType = FLANN_DIST_L2;
+    build(_data, params, _distType);
+}
+    
+void Index::build(InputArray _data, const IndexParams& params, flann_distance_t _distType)
+{
+    release();
+    algo = getParam<flann_algorithm_t>(params, "algorithm", FLANN_INDEX_LINEAR);
+    if( algo == FLANN_INDEX_SAVED )
+    {
+        load(_data, getParam<std::string>(params, "filename", std::string()));
+        return;
+    }
+    
+    Mat data = _data.getMat();
+    index = 0;
+    featureType = data.type();
+    distType = _distType;
+
+    if( algo == FLANN_INDEX_LSH )
+    {
+        buildIndex_<HammingDistance, LshIndex>(index, data, params);
+        return;
+    }
+    
+    switch( distType )
+    {
+    case FLANN_DIST_L2:
+        buildIndex< ::cvflann::L2<float> >(index, data, params);
+        break;
+    case FLANN_DIST_L1:
+        buildIndex< ::cvflann::L1<float> >(index, data, params);
+        break;
+#if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+    case FLANN_DIST_MAX:
+        buildIndex< ::cvflann::MaxDistance<float> >(index, data, params);
+        break;
+    case FLANN_DIST_HIST_INTERSECT:
+        buildIndex< ::cvflann::HistIntersectionDistance<float> >(index, data, params);
+        break;
+    case FLANN_DIST_HELLINGER:
+        buildIndex< ::cvflann::HellingerDistance<float> >(index, data, params);
+        break;
+    case FLANN_DIST_CHI_SQUARE:
+        buildIndex< ::cvflann::ChiSquareDistance<float> >(index, data, params);
+        break;
+    case FLANN_DIST_KL:
+        buildIndex< ::cvflann::KL_Divergence<float> >(index, data, params);
+        break;
+#endif
+    default:
+        CV_Error(CV_StsBadArg, "Unknown/unsupported distance type");
+    }
+}
+
+template<typename IndexType> void deleteIndex_(void* index)
+{
+    delete (IndexType*)index;
+}
+
+template<typename Distance> void deleteIndex(void* index)
+{
+    deleteIndex_< ::cvflann::Index<Distance> >(index);
+}
+    
+Index::~Index()
+{
+    release();
+}
+    
+void Index::release()
+{
+    if( !index )
+        return;
+    if( algo == FLANN_INDEX_LSH )
+    {
+        deleteIndex_<LshIndex>(index);
+    }
+    else
+    {
+        CV_Assert( featureType == CV_32F );
+        switch( distType )
+        {
+        case FLANN_DIST_L2:
+            deleteIndex< ::cvflann::L2<float> >(index);
+            break;
+        case FLANN_DIST_L1:
+            deleteIndex< ::cvflann::L1<float> >(index);
+            break;
+#if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+        case FLANN_DIST_MAX:
+            deleteIndex< ::cvflann::MaxDistance<float> >(index);
+            break;
+        case FLANN_DIST_HIST_INTERSECT:
+            deleteIndex< ::cvflann::HistIntersectionDistance<float> >(index);
+            break;
+        case FLANN_DIST_HELLINGER:
+            deleteIndex< ::cvflann::HellingerDistance<float> >(index);
+            break;
+        case FLANN_DIST_CHI_SQUARE:
+            deleteIndex< ::cvflann::ChiSquareDistance<float> >(index);
+            break;
+        case FLANN_DIST_KL:
+            deleteIndex< ::cvflann::KL_Divergence<float> >(index);
+            break;
+#endif
+        default:
+            CV_Error(CV_StsBadArg, "Unknown/unsupported distance type");
+        }
+    }
+    index = 0;
+}
+
+template<typename Distance, typename IndexType>
+void runKnnSearch_(void* index, const Mat& query, Mat& indices, Mat& dists,
+                  int knn, const SearchParams& params)
+{
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+    int type = DataType<ElementType>::type;
+    int dtype = DataType<DistanceType>::type;
+    CV_Assert(query.type() == type && indices.type() == CV_32S && dists.type() == dtype);
+    CV_Assert(query.isContinuous() && indices.isContinuous() && dists.isContinuous());
+    
+    ::cvflann::Matrix<ElementType> _query((ElementType*)query.data, query.rows, query.cols);
+    ::cvflann::Matrix<int> _indices((int*)indices.data, indices.rows, indices.cols);
+    ::cvflann::Matrix<DistanceType> _dists((DistanceType*)dists.data, dists.rows, dists.cols);
+    
+    ((IndexType*)index)->knnSearch(_query, _indices, _dists, knn,
+                                   (const ::cvflann::SearchParams&)get_params(params));
+}
+    
+template<typename Distance>
+void runKnnSearch(void* index, const Mat& query, Mat& indices, Mat& dists,
+                  int knn, const SearchParams& params)
+{
+    runKnnSearch_<Distance, ::cvflann::Index<Distance> >(index, query, indices, dists, knn, params);
+}
+
+template<typename Distance, typename IndexType>
+int runRadiusSearch_(void* index, const Mat& query, Mat& indices, Mat& dists,
+                    double radius, const SearchParams& params)
+{
+    typedef typename Distance::ElementType ElementType;
+    typedef typename Distance::ResultType DistanceType;
+    int type = DataType<ElementType>::type;
+    int dtype = DataType<DistanceType>::type;
+    CV_Assert(query.type() == type && indices.type() == CV_32S && dists.type() == dtype);
+    CV_Assert(query.isContinuous() && indices.isContinuous() && dists.isContinuous());
+    
+    ::cvflann::Matrix<ElementType> _query((ElementType*)query.data, query.rows, query.cols);
+    ::cvflann::Matrix<int> _indices((int*)indices.data, indices.rows, indices.cols);
+    ::cvflann::Matrix<DistanceType> _dists((DistanceType*)dists.data, dists.rows, dists.cols);
+    
+    return ((IndexType*)index)->radiusSearch(_query, _indices, _dists,
+                                            saturate_cast<DistanceType>(radius),
+                                            (const ::cvflann::SearchParams&)get_params(params));
+}
+
+template<typename Distance>
+int runRadiusSearch(void* index, const Mat& query, Mat& indices, Mat& dists,
+                     double radius, const SearchParams& params)
+{
+    return runRadiusSearch_<Distance, ::cvflann::Index<Distance> >(index, query, indices, dists, radius, params);
+}
+        
+    
+static void createIndicesDists(OutputArray _indices, OutputArray _dists,
+                               Mat& indices, Mat& dists, int rows,
+                               int minCols, int maxCols, int dtype)
+{
+    if( _indices.needed() )
+    {
+        indices = _indices.getMat();
+        if( !indices.isContinuous() || indices.type() != CV_32S ||
+            indices.rows != rows || indices.cols < minCols || indices.cols > maxCols )
+        {
+            if( !indices.isContinuous() )
+               _indices.release();
+            _indices.create( rows, minCols, CV_32S );
+            indices = _indices.getMat();
+        }
+    }
+    else
+        indices.create( rows, minCols, CV_32S );
+    
+    if( _dists.needed() )
+    {
+        dists = _dists.getMat();
+        if( !dists.isContinuous() || dists.type() != dtype ||
+           dists.rows != rows || dists.cols < minCols || dists.cols > maxCols )
+        {
+            if( !indices.isContinuous() )
+                _dists.release();
+            _dists.create( rows, minCols, dtype );
+            dists = _dists.getMat();
+        }
+    }
+    else
+        dists.create( rows, minCols, dtype );
+}
+
+    
+void Index::knnSearch(InputArray _query, OutputArray _indices, 
+               OutputArray _dists, int knn, const SearchParams& params)
+{
+    Mat query = _query.getMat(), indices, dists;
+    int dtype = algo == FLANN_INDEX_LSH ? CV_32S : CV_32F;
+    
+    createIndicesDists( _indices, _dists, indices, dists, query.rows, knn, knn, dtype );
+    
+    if( algo == FLANN_INDEX_LSH )
+    {
+        runKnnSearch_<HammingDistance, LshIndex>(index, query, indices, dists, knn, params);
+        return;
+    }
+    
+    switch( distType )
+    {
+    case FLANN_DIST_L2:
+        runKnnSearch< ::cvflann::L2<float> >(index, query, indices, dists, knn, params);
+        break;
+    case FLANN_DIST_L1:
+        runKnnSearch< ::cvflann::L1<float> >(index, query, indices, dists, knn, params);
+        break;
+#if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+    case FLANN_DIST_MAX:
+        runKnnSearch< ::cvflann::MaxDistance<float> >(index, query, indices, dists, knn, params);
+        break;
+    case FLANN_DIST_HIST_INTERSECT:
+        runKnnSearch< ::cvflann::HistIntersectionDistance<float> >(index, query, indices, dists, knn, params);
+        break;
+    case FLANN_DIST_HELLINGER:
+        runKnnSearch< ::cvflann::HellingerDistance<float> >(index, query, indices, dists, knn, params);
+        break;
+    case FLANN_DIST_CHI_SQUARE:
+        runKnnSearch< ::cvflann::ChiSquareDistance<float> >(index, query, indices, dists, knn, params);
+        break;
+    case FLANN_DIST_KL:
+        runKnnSearch< ::cvflann::KL_Divergence<float> >(index, query, indices, dists, knn, params);
+        break;
+#endif
+    default:
+        CV_Error(CV_StsBadArg, "Unknown/unsupported distance type");
+    }
+}
+        
+int Index::radiusSearch(InputArray _query, OutputArray _indices,
+                        OutputArray _dists, double radius, int maxResults,
+                        const SearchParams& params)
+{
+    Mat query = _query.getMat(), indices, dists;
+    int dtype = algo == FLANN_INDEX_LSH ? CV_32S : CV_32F;
+    CV_Assert( maxResults > 0 );
+    createIndicesDists( _indices, _dists, indices, dists, query.rows, maxResults, INT_MAX, dtype );
+    
+    if( algo == FLANN_INDEX_LSH )
+        CV_Error( CV_StsNotImplemented, "LSH index does not support radiusSearch operation" );
+    
+    switch( distType )
+    {
+    case FLANN_DIST_L2:
+        return runRadiusSearch< ::cvflann::L2<float> >(index, query, indices, dists, radius, params);
+    case FLANN_DIST_L1:
+        return runRadiusSearch< ::cvflann::L1<float> >(index, query, indices, dists, radius, params);
+#if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+    case FLANN_DIST_MAX:
+        return runRadiusSearch< ::cvflann::MaxDistance<float> >(index, query, indices, dists, radius, params);
+    case FLANN_DIST_HIST_INTERSECT:
+        return runRadiusSearch< ::cvflann::HistIntersectionDistance<float> >(index, query, indices, dists, radius, params);
+    case FLANN_DIST_HELLINGER:
+        return runRadiusSearch< ::cvflann::HellingerDistance<float> >(index, query, indices, dists, radius, params);
+    case FLANN_DIST_CHI_SQUARE:
+        return runRadiusSearch< ::cvflann::ChiSquareDistance<float> >(index, query, indices, dists, radius, params);
+    case FLANN_DIST_KL:
+        return runRadiusSearch< ::cvflann::KL_Divergence<float> >(index, query, indices, dists, radius, params);
+#endif
+    default:
+        CV_Error(CV_StsBadArg, "Unknown/unsupported distance type");
+    }
+    return -1;
+}
+
+flann_distance_t Index::getDistance() const
+{
+    return distType;
+}
+    
+flann_algorithm_t Index::getAlgorithm() const
+{
+    return algo;
+}
+
+template<typename IndexType> void saveIndex_(const Index* index0, const void* index, FILE* fout)
+{
+    IndexType* _index = (IndexType*)index;
+    ::cvflann::save_header(fout, *_index);
+    // some compilers may store short enumerations as bytes,
+    // so make sure we always write integers (which are 4-byte values in any modern C compiler)
+    int idistType = (int)index0->getDistance();
+    ::cvflann::save_value<int>(fout, idistType);
+    _index->saveIndex(fout);
+}
+
+template<typename Distance> void saveIndex(const Index* index0, const void* index, FILE* fout)
+{
+    saveIndex_< ::cvflann::Index<Distance> >(index0, index, fout);
+}   
+    
+void Index::save(const std::string& filename) const
+{
+    FILE* fout = fopen(filename.c_str(), "wb");
+    if (fout == NULL)
+        CV_Error_( CV_StsError, ("Can not open file %s for writing FLANN index\n", filename.c_str()) );
+    
+    if( algo == FLANN_INDEX_LSH )
+    {
+        saveIndex_<LshIndex>(this, index, fout);
+        return;
+    }
+    
+    switch( distType )
+    {
+    case FLANN_DIST_L2:
+        saveIndex< ::cvflann::L2<float> >(this, index, fout);
+        break;
+    case FLANN_DIST_L1:
+        saveIndex< ::cvflann::L1<float> >(this, index, fout);
+        break;
+#if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+    case FLANN_DIST_MAX:
+        saveIndex< ::cvflann::MaxDistance<float> >(this, index, fout);
+        break;
+    case FLANN_DIST_HIST_INTERSECT:
+        saveIndex< ::cvflann::HistIntersectionDistance<float> >(this, index, fout);
+        break;
+    case FLANN_DIST_HELLINGER:
+        saveIndex< ::cvflann::HellingerDistance<float> >(this, index, fout);
+        break;
+    case FLANN_DIST_CHI_SQUARE:
+        saveIndex< ::cvflann::ChiSquareDistance<float> >(this, index, fout);
+        break;
+    case FLANN_DIST_KL:
+        saveIndex< ::cvflann::KL_Divergence<float> >(this, index, fout);
+        break;
+#endif
+    default:
+        fclose(fout);
+        fout = 0;
+        CV_Error(CV_StsBadArg, "Unknown/unsupported distance type");
+    }
+    if( fout )
+        fclose(fout);
+}
+
+
+template<typename Distance, typename IndexType>
+bool loadIndex_(Index* index0, void*& index, const Mat& data, FILE* fin, const Distance& dist=Distance())
+{
+    typedef typename Distance::ElementType ElementType;
+    CV_Assert(DataType<ElementType>::type == data.type() && data.isContinuous());
+    
+    ::cvflann::Matrix<ElementType> dataset((ElementType*)data.data, data.rows, data.cols);
+    
+    ::cvflann::IndexParams params;
+    params["algorithm"] = index0->getAlgorithm();
+    IndexType* _index = new IndexType(dataset, params, dist);
+    _index->loadIndex(fin);
+    index = _index;
+    return true;
+}
+
+template<typename Distance>
+bool loadIndex(Index* index0, void*& index, const Mat& data, FILE* fin, const Distance& dist=Distance())
+{
+    return loadIndex_<Distance, ::cvflann::Index<Distance> >(index0, index, data, fin, dist);
+}    
+    
+bool Index::load(InputArray _data, const std::string& filename)
+{
+    Mat data = _data.getMat();
+    bool ok = true;
+    release();
+    FILE* fin = fopen(filename.c_str(), "rb");
+    if (fin == NULL)
+        return false;
+    
+    ::cvflann::IndexHeader header = ::cvflann::load_header(fin);
+    algo = header.index_type;
+    featureType = header.data_type == FLANN_UINT8 ? CV_8U :
+                  header.data_type == FLANN_INT8 ? CV_8S :
+                  header.data_type == FLANN_UINT16 ? CV_16U :
+                  header.data_type == FLANN_INT16 ? CV_16S :
+                  header.data_type == FLANN_INT32 ? CV_32S :
+                  header.data_type == FLANN_FLOAT32 ? CV_32F :
+                  header.data_type == FLANN_FLOAT64 ? CV_64F : -1;
+    
+    if( (int)header.rows != data.rows || (int)header.cols != data.cols ||
+        featureType != data.type() )
+    {
+        fprintf(stderr, "Reading FLANN index error: the saved data size (%d, %d) or type (%d) is different from the passed one (%d, %d), %d\n",
+                (int)header.rows, (int)header.cols, featureType, data.rows, data.cols, data.type());
+        fclose(fin);
+        return false;
+    }
+    
+    if( !((algo == FLANN_INDEX_LSH && featureType == CV_8U) ||
+          (algo != FLANN_INDEX_LSH && featureType == CV_32F)) )
+    {
+        fprintf(stderr, "Reading FLANN index error: unsupported feature type %d for the index type %d\n", featureType, algo);
+        fclose(fin);
+        return false;
+    }
+    int idistType = 0;
+    ::cvflann::load_value(fin, idistType);
+    distType = (flann_distance_t)idistType;
+    
+    if( algo == FLANN_INDEX_LSH )
+    {
+        loadIndex_<HammingDistance, LshIndex>(this, index, data, fin);
+    }
+    else
+    {
+        switch( distType )
+        {
+        case FLANN_DIST_L2:
+            loadIndex< ::cvflann::L2<float> >(this, index, data, fin);
+            break;
+        case FLANN_DIST_L1:
+            loadIndex< ::cvflann::L1<float> >(this, index, data, fin);
+            break;
+    #if MINIFLANN_SUPPORT_EXOTIC_DISTANCE_TYPES
+        case FLANN_DIST_MAX:
+            loadIndex< ::cvflann::MaxDistance<float> >(this, index, data, fin);
+            break;
+        case FLANN_DIST_HIST_INTERSECT:
+            loadIndex< ::cvflann::HistIntersectionDistance<float> >(index, data, fin);
+            break;
+        case FLANN_DIST_HELLINGER:
+            loadIndex< ::cvflann::HellingerDistance<float> >(this, index, data, fin);
+            break;
+        case FLANN_DIST_CHI_SQUARE:
+            loadIndex< ::cvflann::ChiSquareDistance<float> >(this, index, data, fin);
+            break;
+        case FLANN_DIST_KL:
+            loadIndex< ::cvflann::KL_Divergence<float> >(this, index, data, fin);
+            break;
+    #endif
+        default:
+            fprintf(stderr, "Reading FLANN index error: unsupported distance type %d\n", distType);
+            ok = false;
+        }
+    }
+    
+    if( fin )
+        fclose(fin);
+    return ok;
+}
+    
+}
+    
+}
diff --git a/modules/flann/src/precomp.hpp b/modules/flann/src/precomp.hpp
index 8c511ced52..7678a47ebc 100644
--- a/modules/flann/src/precomp.hpp
+++ b/modules/flann/src/precomp.hpp
@@ -5,10 +5,13 @@
 #include <cstdarg>
 #include <sstream>
 
+#include "opencv2/flann/miniflann.hpp"
 #include "opencv2/flann/dist.h"
 #include "opencv2/flann/index_testing.h"
+#include "opencv2/flann/params.h"
 #include "opencv2/flann/saving.h"
 #include "opencv2/flann/general.h"
+#include "opencv2/flann/dummy.h"
 
 // index types
 #include "opencv2/flann/all_indices.h"
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 06778053ec..b9f36664f2 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -6,8 +6,8 @@ project(${the_target})
 set(DEPS "opencv_core" "opencv_imgproc" "opencv_objdetect" "opencv_features2d" "opencv_flann" "opencv_calib3d") #"opencv_features2d" "opencv_flann" "opencv_objdetect" - only headers needed 
 set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} opencv_gpu)
 
-include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"                    
-					"${CMAKE_CURRENT_SOURCE_DIR}/src/cuda"                    
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
+					"${CMAKE_CURRENT_SOURCE_DIR}/src/cuda"
 					"${CMAKE_CURRENT_SOURCE_DIR}/src"
 					"${CMAKE_CURRENT_BINARY_DIR}")
 
@@ -23,7 +23,9 @@ source_group("Include" FILES ${lib_hdrs})
 
 #file(GLOB lib_device_hdrs "include/opencv2/${name}/device/*.h*")
 file(GLOB lib_device_hdrs "src/opencv2/gpu/device/*.h*")
+file(GLOB lib_device_hdrs_detail "src/opencv2/gpu/device/detail/*.h*")
 source_group("Device" FILES ${lib_device_hdrs})
+source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
 if (HAVE_CUDA)
     file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp")	
@@ -83,19 +85,7 @@ foreach(d ${DEPS})
 	endif()
 endforeach()
 
-add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${lib_device_hdrs} ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda} ${cuda_objs})
-
-if(PCHSupport_FOUND)
-	set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
-	if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-		if(${CMAKE_GENERATOR} MATCHES "Visual*")
-			set(${the_target}_pch "src/precomp.cpp")
-		endif()
-		add_native_precompiled_header(${the_target} ${pch_header})
-	elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-		add_precompiled_header(${the_target} ${pch_header})
-	endif()
-endif()
+add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${lib_device_hdrs} ${lib_device_hdrs_detail} ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda} ${cuda_objs})
 
 # For dynamic link numbering convenions
 set_target_properties(${the_target} PROPERTIES
@@ -112,36 +102,38 @@ if (BUILD_SHARED_LIBS)
 	if (MSVC)
 		set_target_properties(${the_target} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
 	else()
-		add_definitions(-DCVAPI_EXPORTS)	   
-	endif()	
+		add_definitions(-DCVAPI_EXPORTS)
+	endif()
 endif()
 
+add_opencv_precompiled_headers(${the_target})
+
 # Additional target properties
 set_target_properties(${the_target} PROPERTIES
-	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
     ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
     RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
     INSTALL_NAME_DIR lib
-	)
+    )
 
 # Add the required libraries for linking:
 target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} )
 
 if (HAVE_CUDA)
-	target_link_libraries(${the_target} ${CUDA_LIBRARIES})    
+    target_link_libraries(${the_target} ${CUDA_LIBRARIES})    
     CUDA_ADD_CUFFT_TO_TARGET(${the_target})
-	
-	unset(CUDA_npp_LIBRARY CACHE)
-	find_cuda_helper_libs(npp)
-	target_link_libraries(${the_target} ${CUDA_npp_LIBRARY})    		
+
+    unset(CUDA_npp_LIBRARY CACHE)
+    find_cuda_helper_libs(npp)
+    target_link_libraries(${the_target} ${CUDA_npp_LIBRARY})
 endif()
 
 if(MSVC)
-	if(CMAKE_CROSSCOMPILING)
-		set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:secchk")
-	endif()
-    
-	set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:libc")
+    if(CMAKE_CROSSCOMPILING)
+        set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:secchk")
+    endif()
+
+    set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:libc")
 endif()
 
 # Dependencies of this target:
@@ -149,19 +141,19 @@ add_dependencies(${the_target} ${DEPS})
 
 install(TARGETS ${the_target}
 	RUNTIME DESTINATION bin COMPONENT main
-	LIBRARY DESTINATION lib COMPONENT main
-	ARCHIVE DESTINATION lib COMPONENT main)
+	LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
+	ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 
 install(FILES ${lib_hdrs}
-	DESTINATION include/opencv2/${name}
+	DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/${name}
 	COMPONENT main)
 
 install(FILES src/nvidia/NPP_staging/NPP_staging.hpp  src/nvidia/core/NCV.hpp
-	DESTINATION include/opencv2/${name}
+	DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/${name}
 	COMPONENT main)
 
 #install(FILES ${lib_device_hdrs}
-#	DESTINATION include/opencv2/${name}/device
+#	DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/${name}/device
 #	COMPONENT main)
 
 
@@ -181,11 +173,8 @@ if(BUILD_TESTS AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
     set(test_deps opencv_${name} opencv_ts opencv_highgui opencv_calib3d ${DEPS})
     foreach(d ${test_deps})
         if(${d} MATCHES "opencv_")
-            if(${d} MATCHES "opencv_lapack")
-            else()
-                string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
-                include_directories("${d_dir}/include")
-            endif()
+            string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
+            include_directories("${d_dir}/include")
         endif()
     endforeach()
     
@@ -203,17 +192,7 @@ if(BUILD_TESTS AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
     
     add_executable(${the_test_target} ${test_srcs} ${test_hdrs} ${nvidia})
     
-    if(PCHSupport_FOUND)
-        set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/test/test_precomp.hpp)
-        if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-            if(${CMAKE_GENERATOR} MATCHES "Visual*")
-                set(${the_test_target}_pch "test/test_precomp.cpp")
-            endif()            
-            add_native_precompiled_header(${the_test_target} ${pch_header})
-        elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-            add_precompiled_header(${the_test_target} ${pch_header})
-        endif()
-    endif()
+    add_opencv_precompiled_headers(${the_test_target})
     
     # Additional target properties
     set_target_properties(${the_test_target} PROPERTIES
@@ -223,7 +202,7 @@ if(BUILD_TESTS AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/test)
 	
 	if(ENABLE_SOLUTION_FOLDERS)
 		set_target_properties(${the_test_target} PROPERTIES FOLDER "tests")
-	endif()			
+	endif()
     
     add_dependencies(${the_test_target} ${test_deps})
     
diff --git a/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst b/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
index 13b654925e..423f7233b7 100644
--- a/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
+++ b/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
@@ -3,8 +3,6 @@ Camera Calibration and 3D Reconstruction
 
 .. highlight:: cpp
 
-.. index:: gpu::StereoBM_GPU
-
 gpu::StereoBM_GPU
 -----------------
 .. ocv:class:: gpu::StereoBM_GPU
@@ -87,16 +85,12 @@ gpu::StereoBM_GPU::operator ()
 
     :param stream: Stream for the asynchronous version.
 
-.. index:: gpu::StereoBM_GPU::checkIfGpuCallReasonable
-
 gpu::StereoBM_GPU::checkIfGpuCallReasonable
 -----------------------------------------------
 .. ocv:function:: bool gpu::StereoBM_GPU::checkIfGpuCallReasonable()
 
     Uses a heuristic method to estimate whether the current GPU is faster than the CPU in this algorithm. It queries the currently active device.
 
-.. index:: gpu::StereoBeliefPropagation
-
 gpu::StereoBeliefPropagation
 ----------------------------
 .. ocv:class:: gpu::StereoBeliefPropagation
@@ -163,8 +157,6 @@ The class implements algorithm described in [Felzenszwalb2006]_ . It can compute
     ``width_step`` is the number of bytes in a line including padding.
 
 
-.. index:: gpu::StereoBeliefPropagation::StereoBeliefPropagation
-
 gpu::StereoBeliefPropagation::StereoBeliefPropagation
 ---------------------------------------------------------
 .. ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F)
@@ -207,8 +199,6 @@ By default, :ocv:class:`StereoBeliefPropagation` uses floating-point arithmetics
 
     10  \cdot 2^{levels-1}  \cdot max \_ data \_ term < SHRT \_ MAX
 
-.. index:: gpu::StereoBeliefPropagation::estimateRecommendedParams
-
 gpu::StereoBeliefPropagation::estimateRecommendedParams
 -----------------------------------------------------------
 
@@ -216,36 +206,28 @@ gpu::StereoBeliefPropagation::estimateRecommendedParams
 
     Uses a heuristic method to compute the recommended parameters (``ndisp``, ``iters`` and ``levels``) for the specified image size (``width`` and ``height``).
 
-.. index:: gpu::StereoBeliefPropagation::operator ()
-
 gpu::StereoBeliefPropagation::operator ()
 ---------------------------------------------
 .. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
 
 .. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream)
 
+.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity)
+
+.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream)
+
     Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair or data cost.
 
     :param left: Left image. ``CV_8UC1`` , ``CV_8UC3``  and  ``CV_8UC4``  types are supported.
 
     :param right: Right image with the same size and the same type as the left one.
 
-    :param disparity: Output disparity map. If  ``disparity``  is empty, the output type is  ``CV_16SC1`` . Otherwise, the output type is  ``disparity.type()`` .
-
-    :param stream: Stream for the asynchronous version.
-
-.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity)
-
-.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream)
-
     :param data: User-specified data cost, a matrix of ``msg_type`` type and ``Size(<image columns>*ndisp, <image rows>)`` size.
 
-    :param disparity: Output disparity map. If the matrix is empty, it is created as the ``CV_16SC1`` matrix. Otherwise, the type is retained.
+    :param disparity: Output disparity map. If  ``disparity``  is empty, the output type is  ``CV_16SC1`` . Otherwise, the type is retained.
 
     :param stream: Stream for the asynchronous version.
 
-.. index:: gpu::StereoConstantSpaceBP
-
 gpu::StereoConstantSpaceBP
 --------------------------
 .. ocv:class:: gpu::StereoConstantSpaceBP
@@ -303,8 +285,6 @@ Class computing stereo correspondence using the constant space belief propagatio
 
 The class implements algorithm described in [Yang2010]_. ``StereoConstantSpaceBP`` supports both local minimum and global minimum data cost initialization algortihms. For more details, see the paper mentioned above. By default, a local algorithm is used. To enable a global algorithm, set ``use_local_init_data_cost`` to ``false``.
 
-.. index:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP
-
 gpu::StereoConstantSpaceBP::StereoConstantSpaceBP
 -----------------------------------------------------
 .. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F)
@@ -351,8 +331,6 @@ By default, ``StereoConstantSpaceBP`` uses floating-point arithmetics and the ``
 
     10  \cdot 2^{levels-1}  \cdot max \_ data \_ term < SHRT \_ MAX
 
-.. index:: gpu::StereoConstantSpaceBP::estimateRecommendedParams
-
 gpu::StereoConstantSpaceBP::estimateRecommendedParams
 ---------------------------------------------------------
 
@@ -360,8 +338,6 @@ gpu::StereoConstantSpaceBP::estimateRecommendedParams
 
     Uses a heuristic method to compute parameters (ndisp, iters, levelsand nrplane) for the specified image size (widthand height).
 
-.. index:: gpu::StereoConstantSpaceBP::operator ()
-
 gpu::StereoConstantSpaceBP::operator ()
 -------------------------------------------
 .. ocv:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity)
@@ -378,10 +354,6 @@ gpu::StereoConstantSpaceBP::operator ()
 
     :param stream: Stream for the asynchronous version.
 
-.. index:: gpu::DisparityBilateralFilter
-
-.. _gpu::DisparityBilateralFilter:
-
 gpu::DisparityBilateralFilter
 -----------------------------
 .. ocv:class:: gpu::DisparityBilateralFilter
@@ -413,8 +385,6 @@ Class refinining a disparity map using joint bilateral filtering. ::
 
 The class implements [Yang2010]_ algorithm.
 
-.. index:: gpu::DisparityBilateralFilter::DisparityBilateralFilter
-
 gpu::DisparityBilateralFilter::DisparityBilateralFilter
 -----------------------------------------------------------
 .. ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS)
@@ -435,8 +405,6 @@ gpu::DisparityBilateralFilter::DisparityBilateralFilter
 
     :param sigma_range: Filter range.
 
-.. index:: gpu::DisparityBilateralFilter::operator ()
-
 gpu::DisparityBilateralFilter::operator ()
 ----------------------------------------------
 .. ocv:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst)
@@ -453,8 +421,6 @@ gpu::DisparityBilateralFilter::operator ()
 
     :param stream: Stream for the asynchronous version.
 
-.. index:: gpu::drawColorDisp
-
 gpu::drawColorDisp
 ----------------------
 .. ocv:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp)
@@ -473,8 +439,6 @@ gpu::drawColorDisp
 
 This function draws a colored disparity map by converting disparity values from ``[0..ndisp)`` interval first to ``HSV`` color space (where different disparity values correspond to different hues) and then converting the pixels to ``RGB`` for visualization.
 
-.. index:: gpu::reprojectImageTo3D
-
 gpu::reprojectImageTo3D
 ---------------------------
 .. ocv:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q)
@@ -491,10 +455,6 @@ gpu::reprojectImageTo3D
 
     :param stream: Stream for the asynchronous version.
 
-.. seealso:: :ocv:func:`reprojectImageTo3D` .
-
-.. index:: gpu::solvePnPRansac
-
 gpu::solvePnPRansac
 -------------------
 
diff --git a/modules/gpu/doc/data_structures.rst b/modules/gpu/doc/data_structures.rst
index d9442872e3..dd22f472f8 100644
--- a/modules/gpu/doc/data_structures.rst
+++ b/modules/gpu/doc/data_structures.rst
@@ -37,6 +37,7 @@ Lightweight class encapsulating pitched memory on a GPU and passed to nvcc-compi
     typedef DevMem2D_<unsigned char> DevMem2D;
     typedef DevMem2D_<float> DevMem2Df;
     typedef DevMem2D_<int> DevMem2Di;
+
 ..
 
 
@@ -108,6 +109,7 @@ Base storage class for GPU memory with reference counting. Its interface matches
 Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :ocv:class:`gpu::DevMem2D_` and :ocv:class:`gpu::PtrStep_` so it can be passed directly to the kernel.
 
 .. note:: In contrast with :ocv:class:`Mat`, in most cases ``GpuMat::isContinuous() == false`` . This means that rows are aligned to a size depending on the hardware. Single-row ``GpuMat`` is always a continuous matrix. 
+
 ::
 
     class CV_EXPORTS GpuMat
@@ -144,10 +146,10 @@ Beware that the latter limitation may lead to overloaded matrix operators that c
 
 .. note:: 
 
-	You are not recommended to leave static or global ``GpuMat`` variables allocated, that is, to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
+    You are not recommended to leave static or global ``GpuMat`` variables allocated, that is, to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before.
 
 .. seealso:: 
-:ocv:class:`Mat`
+   :ocv:class:`Mat`
 
 .. index:: gpu::CudaMem
 
@@ -166,8 +168,8 @@ Class with reference counting wrapping special memory type allocation functions
     ``ALLOC_WRITE_COMBINED``  sets the write combined buffer that is not cached by CPU. Such buffers are used to supply GPU with data when GPU only reads it. The advantage is a better CPU cache utilization.
 
 .. note:: 
+   Allocation size of such memory types is usually limited. For more details, see *CUDA 2.2 Pinned Memory APIs* document or *CUDA C Programming Guide*.
 
-	Allocation size of such memory types is usually limited. For more details, see *CUDA 2.2 Pinned Memory APIs* document or *CUDA C Programming Guide*.
 ::
 
     class CV_EXPORTS CudaMem
@@ -235,8 +237,8 @@ gpu::Stream
 This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :ocv:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :ocv:class:`gpu::CudaMem` or :ocv:class:`Mat` header that points to a region of :ocv:class:`gpu::CudaMem`.
 
 .. note::
- 
-	Currently, you may face problems if an operation is enqueued twice with different data. Some functions use the constant GPU memory, and next call may update the memory before the previous one has been finished. But calling different operations asynchronously is safe because each operation has its own constant buffer. Memory copy/upload/download/set operations to the buffers you hold are also safe. 
+   Currently, you may face problems if an operation is enqueued twice with different data. Some functions use the constant GPU memory, and next call may update the memory before the previous one has been finished. But calling different operations asynchronously is safe because each operation has its own constant buffer. Memory copy/upload/download/set operations to the buffers you hold are also safe. 
+
 ::
 
     class CV_EXPORTS Stream
@@ -324,11 +326,11 @@ gpu::createContinuous
     The following wrappers are also available:
     
     
-		* .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
+        * .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type)
     
-		* .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
+        * .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m)
     
-		* .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
+        * .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type)
 
     Matrix is called continuous if its elements are stored continuously, that is, without gaps at the end of each row.
 
diff --git a/modules/gpu/doc/feature_detection_and_description.rst b/modules/gpu/doc/feature_detection_and_description.rst
index ef4b5528ab..af95c2bba2 100644
--- a/modules/gpu/doc/feature_detection_and_description.rst
+++ b/modules/gpu/doc/feature_detection_and_description.rst
@@ -3,7 +3,7 @@ Feature Detection and Description
 
 .. highlight:: cpp
 
-.. index:: gpu::SURF_GPU
+
 
 gpu::SURF_GPU
 -------------
@@ -97,9 +97,9 @@ The ``descriptors`` matrix is :math:`\texttt{nFeatures} \times \texttt{descripto
 The class ``SURF_GPU`` uses some buffers and provides access to it. All buffers can be safely released between function calls.
 
 .. seealso:: 
-:ocv:class:`SURF`
+   :ocv:class:`SURF`
+
 
-.. index:: gpu::BruteForceMatcher_GPU
 
 gpu::BruteForceMatcher_GPU
 --------------------------
@@ -193,10 +193,10 @@ Brute-force descriptor matcher. For each descriptor in the first set, this match
 The class ``BruteForceMatcher_GPU`` has an interface similar to the class :ocv:class:`DescriptorMatcher`. It has two groups of ``match`` methods: for matching descriptors of one image with another image or with an image set. Also, all functions have an alternative to save results either to the GPU memory or to the CPU memory. The ``Distance`` template parameter is kept for CPU/GPU interfaces similarity. ``BruteForceMatcher_GPU`` supports only the ``L1<float>``, ``L2<float>``, and ``Hamming`` distance types.
 
 .. seealso:: 
-:ocv:class:`DescriptorMatcher`, 
-:ocv:class:`BruteForceMatcher`
+  :ocv:class:`DescriptorMatcher`, 
+  :ocv:class:`BruteForceMatcher`
+
 
-.. index:: gpu::BruteForceMatcher_GPU::match
 
 gpu::BruteForceMatcher_GPU::match
 -------------------------------------
@@ -207,9 +207,9 @@ gpu::BruteForceMatcher_GPU::match
     Finds the best match for each descriptor from a query set with train descriptors.
 
 .. seealso::
-:ocv:func:`DescriptorMatcher::match` 
+   :ocv:func:`DescriptorMatcher::match` 
+
 
-.. index:: gpu::BruteForceMatcher_GPU::matchSingle
 
 gpu::BruteForceMatcher_GPU::matchSingle
 -------------------------------------------
@@ -227,13 +227,13 @@ gpu::BruteForceMatcher_GPU::matchSingle
 
     :param mask: Mask specifying permissible matches between the input query and train matrices of descriptors.
 
-.. index:: gpu::BruteForceMatcher_GPU::matchCollection
+
 
 gpu::BruteForceMatcher_GPU::matchCollection
 -----------------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection)
 
-	Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
+    Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory.
 
    :param queryDescs: Query set of descriptors.
     
@@ -247,16 +247,16 @@ gpu::BruteForceMatcher_GPU::matchCollection
 
    :param maskCollection: ``GpuMat``  containing a set of masks. It can be obtained from  ``std::vector<GpuMat>``  by  :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain  a user-defined mask set. This is an empty matrix or one-row matrix where each element is a  ``PtrStep``  that points to one mask.
 
-.. index:: gpu::BruteForceMatcher_GPU::makeGpuCollection
+
 
 gpu::BruteForceMatcher_GPU::makeGpuCollection
 -------------------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector<GpuMat>&masks = std::vector<GpuMat>())
 
-	Performs a GPU collection of train descriptors and masks in a suitable format for the 
-	:ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
+    Performs a GPU collection of train descriptors and masks in a suitable format for the 
+    :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function.
+
 
-.. index:: gpu::BruteForceMatcher_GPU::matchDownload
 
 gpu::BruteForceMatcher_GPU::matchDownload
 ---------------------------------------------
@@ -264,30 +264,21 @@ gpu::BruteForceMatcher_GPU::matchDownload
 
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>&matches)
 
-	Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via 
-	:ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or 
-	:ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :ocv:class:`DMatch`.
+    Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via 
+    :ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or 
+    :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :ocv:class:`DMatch`.
+
 
-.. index:: gpu::BruteForceMatcher_GPU::knnMatch
 
 gpu::BruteForceMatcher_GPU::knnMatch
 ----------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false)
 
-    Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance.
+.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, int k, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false )
 
-.. ocv:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, int k, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false )
-
-.. seealso::
-:ocv:func:`DescriptorMatcher::knnMatch` 
-
-.. index:: gpu::BruteForceMatcher_GPU::knnMatch
-
-gpu::BruteForceMatcher_GPU::knnMatch
-----------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat())
 
-    Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance. Results are stored in the GPU memory.
+    Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance.
 
     :param queryDescs: Query set of descriptors.
     :param trainDescs: Training set of descriptors. It is not be added to train descriptors collection stored in the class object.
@@ -299,7 +290,11 @@ gpu::BruteForceMatcher_GPU::knnMatch
 
     :param mask: Mask specifying permissible matches between the input query and train matrices of descriptors.
 
-.. index:: gpu::BruteForceMatcher_GPU::knnMatchDownload
+The third variant of the method stores the results in GPU memory.
+
+.. seealso::
+   :ocv:func:`DescriptorMatcher::knnMatch` 
+
 
 gpu::BruteForceMatcher_GPU::knnMatchDownload
 ------------------------------------------------
@@ -307,28 +302,17 @@ gpu::BruteForceMatcher_GPU::knnMatchDownload
 
     Downloads ``trainIdx`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :ocv:class:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
 
-.. index:: gpu::BruteForceMatcher_GPU::radiusMatch
+
 
 gpu::BruteForceMatcher_GPU::radiusMatch
 -------------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false)
 
-    For each query descriptor, finds the best matches with a distance less than a given threshold. The function returns detected matches in the increasing order by distance.
-
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >&matches, float maxDistance, const std::vector<GpuMat>&masks = std::vector<GpuMat>(), bool compactResult = false)
 
-This function works only on devices with the compute capability  :math:`>=` 1.1.
-
-.. seealso::
-:ocv:func:`DescriptorMatcher::radiusMatch` 
-
-.. index:: gpu::BruteForceMatcher_GPU::radiusMatch
-
-gpu::BruteForceMatcher_GPU::radiusMatch
--------------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance, const GpuMat& mask = GpuMat())
 
-    For each query descriptor, finds the best matches with a distance less than a given threshold (``maxDistance``). The results are stored in the GPU memory.
+    For each query descriptor, finds the best matches with a distance less than a given threshold. The function returns detected matches in the increasing order by distance.
 
     :param queryDescs: Query set of descriptors.
     
@@ -344,13 +328,16 @@ gpu::BruteForceMatcher_GPU::radiusMatch
 
     :param mask: Mask specifying permissible matches between the input query and train matrices of descriptors.
 
-    In contrast to :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1.
+The methods work only on devices with the compute capability  :math:`>=` 1.1.
+The third variant of the method stores the results in GPU memory and does not store the points by the distance.
+
+.. seealso::
+   :ocv:func:`DescriptorMatcher::radiusMatch` 
 
-.. index:: gpu::BruteForceMatcher_GPU::radiusMatchDownload
 
 gpu::BruteForceMatcher_GPU::radiusMatchDownload
 ---------------------------------------------------
 .. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector<DMatch> >&matches, bool compactResult = false)
 
-	Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :ocv:class:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
+    Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :ocv:class:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors.
 
diff --git a/modules/gpu/doc/image_filtering.rst b/modules/gpu/doc/image_filtering.rst
index cb066be5d0..9b5521d310 100644
--- a/modules/gpu/doc/image_filtering.rst
+++ b/modules/gpu/doc/image_filtering.rst
@@ -116,17 +116,17 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem
 
 .. seealso:: 
 
-    :ocv:class:`gpu::BaseRowFilter_GPU`, 
-    :ocv:class:`gpu::BaseColumnFilter_GPU`, 
-    :ocv:class:`gpu::BaseFilter_GPU`, 
-    :ocv:func:`gpu::createFilter2D_GPU`, 
-    :ocv:func:`gpu::createSeparableFilter_GPU`, 
-    :ocv:func:`gpu::createBoxFilter_GPU`, 
-    :ocv:func:`gpu::createMorphologyFilter_GPU`, 
-    :ocv:func:`gpu::createLinearFilter_GPU`, 
-    :ocv:func:`gpu::createSeparableLinearFilter_GPU`, 
-    :ocv:func:`gpu::createDerivFilter_GPU`, 
-    :ocv:func:`gpu::createGaussianFilter_GPU`
+   :ocv:class:`gpu::BaseRowFilter_GPU`, 
+   :ocv:class:`gpu::BaseColumnFilter_GPU`, 
+   :ocv:class:`gpu::BaseFilter_GPU`, 
+   :ocv:func:`gpu::createFilter2D_GPU`, 
+   :ocv:func:`gpu::createSeparableFilter_GPU`, 
+   :ocv:func:`gpu::createBoxFilter_GPU`, 
+   :ocv:func:`gpu::createMorphologyFilter_GPU`, 
+   :ocv:func:`gpu::createLinearFilter_GPU`, 
+   :ocv:func:`gpu::createSeparableLinearFilter_GPU`, 
+   :ocv:func:`gpu::createDerivFilter_GPU`, 
+   :ocv:func:`gpu::createGaussianFilter_GPU`
 
 .. index:: gpu::createFilter2D_GPU
 
@@ -240,7 +240,7 @@ gpu::boxFilter
 
     :param anchor: Anchor point. The default value ``Point(-1, -1)`` means that the anchor is at the kernel center.
 
- .. note::	This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+ .. note::    This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
 
 .. seealso:: :ocv:func:`boxFilter`
 
@@ -307,8 +307,8 @@ gpu::erode
     :param iterations: Number of times erosion to be applied.
 
 .. note:: 
-	
-	This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+    
+    This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
 
 .. seealso:: :ocv:func:`erode`
 
@@ -365,7 +365,7 @@ gpu::morphologyEx
 
     :param iterations: Number of times erosion and dilation to be applied.
 
-.. note::	This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+.. note::    This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
 
 .. seealso:: :ocv:func:`morphologyEx` 
 
@@ -410,8 +410,8 @@ gpu::filter2D
     :param kernel: 2D array of filter coefficients. This filter works with integers kernels. If  ``kernel``  has a ``float``  or  ``double``  type, it uses fixed-point arithmetic.
 
     :param anchor: Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor resides within the kernel. The special default value (-1,-1) means that the anchor is at the kernel cente
-	
-	This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+    
+    This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
 
 .. seealso:: :ocv:func:`filter2D`
 
@@ -433,7 +433,7 @@ gpu::Laplacian
 
     :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see  :ocv:func:`getDerivKernels` ).
 
-.. note::	This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+.. note::    This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
 
 .. seealso:: :ocv:func:`Laplacian`,:ocv:func:`gpu::filter2D` .
 
@@ -455,7 +455,7 @@ gpu::getLinearRowFilter_GPU
 
     :param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below.
 
-    There are two versions of the algorithm: NPP and OpenCV.
+There are two versions of the algorithm: NPP and OpenCV.
         
         * NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. 
         
@@ -481,10 +481,10 @@ gpu::getLinearColumnFilter_GPU
 
     :param borderType: Pixel extrapolation method. For details, see  :ocv:func:`borderInterpolate` . For details on limitations, see below.
 
-	There are two versions of the algorithm: NPP and OpenCV.
-	* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. 
-	* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
-	
+    There are two versions of the algorithm: NPP and OpenCV.
+    * NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. 
+    * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image.
+    
 .. seealso:: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`createSeparableLinearFilter`
 
 .. index:: gpu::createSeparableLinearFilter_GPU
@@ -696,4 +696,4 @@ gpu::getMinFilter_GPU
 
     :param anchor: Anchor point. The default value (-1) means that the anchor is at the kernel center.
 
-	.. note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
+    .. note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
diff --git a/modules/gpu/doc/image_processing.rst b/modules/gpu/doc/image_processing.rst
index 9ed7e59452..60c2e4d6f5 100644
--- a/modules/gpu/doc/image_processing.rst
+++ b/modules/gpu/doc/image_processing.rst
@@ -44,7 +44,6 @@ gpu::meanShiftProc
 .. seealso:: :ocv:func:`gpu::meanShiftFiltering` 
 
 
-
 gpu::meanShiftSegmentation
 ------------------------------
 .. ocv:function:: void gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1))
@@ -128,7 +127,6 @@ gpu::cornerHarris
 .. seealso:: :ocv:func:`cornerHarris` 
 
 
-
 gpu::cornerMinEigenVal
 --------------------------
 .. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101)
@@ -172,7 +170,6 @@ gpu::mulSpectrums
 .. seealso:: :ocv:func:`mulSpectrums` 
 
 
-
 gpu::mulAndScaleSpectrums
 -----------------------------
 .. ocv:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false)
@@ -321,7 +318,6 @@ gpu::matchTemplate
 .. seealso:: :ocv:func:`matchTemplate` 
 
 
-
 gpu::remap
 --------------
 .. ocv:function:: void gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap)
@@ -347,7 +343,6 @@ Values of pixels with non-integer coordinates are computed using the bilinear in
 .. seealso:: :ocv:func:`remap` 
 
 
-
 gpu::cvtColor
 -----------------
 .. ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0)
@@ -518,7 +513,6 @@ gpu::copyMakeBorder
 .. seealso:: :ocv:func:`copyMakeBorder`
 
 
-
 gpu::rectStdDev
 -------------------
 .. ocv:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect)
diff --git a/modules/gpu/doc/initalization_and_information.rst b/modules/gpu/doc/initalization_and_information.rst
index cc1e0dcf30..1308cec5f3 100644
--- a/modules/gpu/doc/initalization_and_information.rst
+++ b/modules/gpu/doc/initalization_and_information.rst
@@ -166,9 +166,9 @@ Class providing a set of static methods to check what NVIDIA* card architecture
 
 The following method checks whether the module was built with the support of the given feature:
 
-	.. ocv:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature)
+    .. ocv:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature)
 
-		:param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`.
+        :param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`.
 
 There is a set of methods to check whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s):
 
diff --git a/modules/gpu/doc/introduction.rst b/modules/gpu/doc/introduction.rst
index 775326d1c8..2d2da7fe4a 100644
--- a/modules/gpu/doc/introduction.rst
+++ b/modules/gpu/doc/introduction.rst
@@ -49,7 +49,7 @@ The OpenCV GPU module follows the CUDA Runtime API conventions regarding the mul
 It is also possible to create the context explicitly using the CUDA Driver API, attach, and set the "current" context for all necessary threads. The CUDA Runtime API (and OpenCV functions, respectively) picks it up.
 
 Utilizing Multiple GPUs
----------
+-----------------------
 
 In the current version, each of the OpenCV GPU algorithms can use only a single GPU. So, to utilize multiple GPUs, you have to manually distribute the work between GPUs. Consider the following ways of utilizing multiple GPUs:
 
@@ -74,5 +74,5 @@ While developing algorithms for multiple GPUs, note a data passing overhead. For
 With this algorithm, a dual GPU gave a 180
 %
 performance increase comparing to the single Fermi GPU. For a source code example, see
-https://code.ros.org/svn/opencv/trunk/opencv/examples/gpu/.
+https://code.ros.org/svn/opencv/trunk/opencv/samples/gpu/.
 
diff --git a/modules/gpu/doc/matrix_reductions.rst b/modules/gpu/doc/matrix_reductions.rst
index 99092354de..8a42cd0353 100644
--- a/modules/gpu/doc/matrix_reductions.rst
+++ b/modules/gpu/doc/matrix_reductions.rst
@@ -7,7 +7,7 @@ Matrix Reductions
 
 gpu::meanStdDev
 -------------------
-.. cpp:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
+.. ocv:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev)
 
     Computes a mean value and a standard deviation of matrix elements.
 
@@ -18,7 +18,7 @@ gpu::meanStdDev
     :param stddev: Standard deviation value.
 
 .. seealso:: 
-:ocv:func:`meanStdDev` 
+   :ocv:func:`meanStdDev` 
 
 .. index:: gpu::norm
 
@@ -39,7 +39,7 @@ gpu::norm
     :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
 
 .. seealso:: 
-:ocv:func:`norm`
+   :ocv:func:`norm`
 
 .. index:: gpu::sum
 
@@ -56,7 +56,7 @@ gpu::sum
     :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
 
 .. seealso:: 
-:ocv:func:`sum` 
+   :ocv:func:`sum` 
 
 .. index:: gpu::absSum
 
@@ -107,9 +107,9 @@ gpu::minMax
     :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
 
 The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
-	
+    
 .. seealso:: 
-:ocv:func:`minMaxLoc` 
+   :ocv:func:`minMaxLoc` 
 
 .. index:: gpu::minMaxLoc
 
@@ -137,10 +137,10 @@ gpu::minMaxLoc
 
     :param locbuf: Optional locations buffer to avoid extra memory allocations. It is resized automatically.
 
-	The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
+    The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3.
 
 .. seealso:: 
-:ocv:func:`minMaxLoc` 
+   :ocv:func:`minMaxLoc` 
 
 .. index:: gpu::countNonZero
 
@@ -157,6 +157,6 @@ gpu::countNonZero
     :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically.
 
 The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3.
-	
+    
 .. seealso:: 
-:ocv:func:`countNonZero` 
+   :ocv:func:`countNonZero` 
diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst
index e935beac2d..43c20e2c79 100644
--- a/modules/gpu/doc/object_detection.rst
+++ b/modules/gpu/doc/object_detection.rst
@@ -67,14 +67,9 @@ Interfaces of all methods are kept similar to the ``CPU HOG`` descriptor and det
 
 gpu::HOGDescriptor::HOGDescriptor
 -------------------------------------
-.. ocv:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128),
-   Size block_size=Size(16, 16), Size block_stride=Size(8, 8),
-   Size cell_size=Size(8, 8), int nbins=9,
-   double win_sigma=DEFAULT_WIN_SIGMA,
-   double threshold_L2hys=0.2, bool gamma_correction=true,
-   int nlevels=DEFAULT_NLEVELS)??check the output??
+.. ocv:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16), Size block_stride=Size(8, 8), Size cell_size=Size(8, 8), int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA, double threshold_L2hys=0.2, bool gamma_correction=true, int nlevels=DEFAULT_NLEVELS)
 
-	Creates the ``HOG`` descriptor and detector.
+    Creates the ``HOG`` descriptor and detector.
 
    :param win_size: Detection window size. Align to block size and block stride.
 
@@ -114,7 +109,7 @@ gpu::HOGDescriptor::getBlockHistogramSize
 
 gpu::HOGDescriptor::setSVMDetector
 --------------------------------------
-.. ocv:function:: void gpu::HOGDescriptor::setSVMDetector(const vector<float>\& detector)
+.. ocv:function:: void gpu::HOGDescriptor::setSVMDetector(const vector<float>& detector)
 
     Sets coefficients for the linear SVM classifier.
 
@@ -146,11 +141,9 @@ gpu::HOGDescriptor::getPeopleDetector64x128
 
 gpu::HOGDescriptor::detect
 ------------------------------
-.. ocv:function:: void gpu::HOGDescriptor::detect(const GpuMat\& img,
-   vector<Point>\& found_locations, double hit_threshold=0,
-   Size win_stride=Size(), Size padding=Size())??see output??
+.. ocv:function:: void gpu::HOGDescriptor::detect(const GpuMat& img, vector<Point>& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size())
 
-	Performs object detection without a multi-scale window.
+    Performs object detection without a multi-scale window.
 
    :param img: Source image.  ``CV_8UC1``  and  ``CV_8UC4`` types are supported for now.
 
@@ -166,12 +159,9 @@ gpu::HOGDescriptor::detect
 
 gpu::HOGDescriptor::detectMultiScale
 ----------------------------------------
-.. ocv:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat\& img,
-   vector<Rect>\& found_locations, double hit_threshold=0,
-   Size win_stride=Size(), Size padding=Size(),
-   double scale0=1.05, int group_threshold=2)??the same??
+.. ocv:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat& img, vector<Rect>& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size(), double scale0=1.05, int group_threshold=2)
 
-	Performs object detection with a multi-scale window.
+    Performs object detection with a multi-scale window.
 
    :param img: Source image. See  :ocv:func:`gpu::HOGDescriptor::detect`  for type limitations.
 
@@ -191,11 +181,9 @@ gpu::HOGDescriptor::detectMultiScale
 
 gpu::HOGDescriptor::getDescriptors
 --------------------------------------
-.. ocv:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat\& img,
-   Size win_stride, GpuMat\& descriptors,
-   int descr_format=DESCR_FORMAT_COL_BY_COL)?? the same??
+.. ocv:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat& img, Size win_stride, GpuMat& descriptors, int descr_format=DESCR_FORMAT_COL_BY_COL)
 
-	Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier.
+    Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier.
 
    :param img: Source image. See  :ocv:func:`gpu::HOGDescriptor::detect`  for type limitations.
 
@@ -247,7 +235,7 @@ Cascade classifier class used for object detection.
 
 gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
 -----------------------------------------------------
-.. ocv:function:: gpu::CascadeClassifier_GPU(const string\& filename)
+.. ocv:function:: gpu::CascadeClassifier_GPU(const string& filename)
 
     Loads the classifier from a file.
 
@@ -269,7 +257,7 @@ gpu::CascadeClassifier_GPU::empty
 
 gpu::CascadeClassifier_GPU::load
 ------------------------------------
-.. ocv:function:: bool gpu::CascadeClassifier_GPU::load(const string\& filename)
+.. ocv:function:: bool gpu::CascadeClassifier_GPU::load(const string& filename)
 
     Loads the classifier from a file. The previous content is destroyed.
 
@@ -287,7 +275,7 @@ gpu::CascadeClassifier_GPU::release
 
 gpu::CascadeClassifier_GPU::detectMultiScale
 ------------------------------------------------
-.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
+.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size())
 
     Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
 
@@ -302,6 +290,7 @@ gpu::CascadeClassifier_GPU::detectMultiScale
     :param minSize: Minimum possible object size. Objects smaller than that are ignored.
 
     The function returns the number of detected objects, so you can retrieve them as in the following example: 
+
 ::
 
     gpu::CascadeClassifier_GPU cascade_gpu(...);
diff --git a/modules/gpu/doc/operations_on_matrices.rst b/modules/gpu/doc/operations_on_matrices.rst
index ba9106a467..92d6c720ed 100644
--- a/modules/gpu/doc/operations_on_matrices.rst
+++ b/modules/gpu/doc/operations_on_matrices.rst
@@ -16,7 +16,7 @@ gpu::transpose
     :param dst: Destination matrix.
 
 .. seealso::
-:ocv:func:`transpose` 
+   :ocv:func:`transpose` 
 
 .. index:: gpu::flip
 
@@ -40,7 +40,7 @@ gpu::flip
             
 
 .. seealso::
-:ocv:func:`flip` 
+   :ocv:func:`flip` 
 
 .. index:: gpu::LUT
 
@@ -58,7 +58,7 @@ gpu::LUT
             
 
 .. seealso:: 
-:ocv:func:`LUT` 
+   :ocv:func:`LUT` 
 
 .. index:: gpu::merge
 
@@ -83,7 +83,7 @@ gpu::merge
     :param stream: Stream for the asynchronous version.
 
 .. seealso:: 
-:ocv:func:`merge` 
+   :ocv:func:`merge` 
 
 .. index:: gpu::split
 
@@ -106,7 +106,7 @@ gpu::split
     :param stream: Stream for the asynchronous version.
 
 .. seealso:: 
-:ocv:func:`split`
+   :ocv:func:`split`
 
 .. index:: gpu::magnitude
 
@@ -131,7 +131,7 @@ gpu::magnitude
     :param stream: Stream for the asynchronous version.
 
 .. seealso::
-:ocv:func:`magnitude` 
+   :ocv:func:`magnitude` 
 
 .. index:: gpu::magnitudeSqr
 
@@ -176,7 +176,7 @@ gpu::phase
     :param stream: Stream for the asynchronous version.
 
 .. seealso::
-:ocv:func:`phase` 
+   :ocv:func:`phase` 
 
 .. index:: gpu::cartToPolar
 
@@ -201,7 +201,7 @@ gpu::cartToPolar
     :param stream: Stream for the asynchronous version.
 
 .. seealso::
-:ocv:func:`cartToPolar` 
+   :ocv:func:`cartToPolar` 
 
 .. index:: gpu::polarToCart
 
@@ -226,4 +226,4 @@ gpu::polarToCart
     :param stream: Stream for the asynchronous version.
 
 .. seealso::
-:ocv:func:`polarToCart` 
+   :ocv:func:`polarToCart` 
diff --git a/modules/gpu/doc/per_element_operations.rst b/modules/gpu/doc/per_element_operations.rst
index 89c9870016..94ec745685 100644
--- a/modules/gpu/doc/per_element_operations.rst
+++ b/modules/gpu/doc/per_element_operations.rst
@@ -22,7 +22,7 @@ gpu::add
     :param dst: Destination matrix with the same size and type as ``src1``.
 
 .. seealso:: 
-:ocv:func:`add`
+   :ocv:func:`add`
 
 .. index:: gpu::subtract
 
@@ -41,7 +41,7 @@ gpu::subtract
     :param dst: Destination matrix with the same size and type as ``src1``.
 
 .. seealso:: 
-:ocv:func:`subtract`
+   :ocv:func:`subtract`
 
 
 
@@ -62,7 +62,7 @@ gpu::multiply
     :param dst: Destination matrix with the same size and type as ``src1``.
 
 .. seealso:: 
-:ocv:func:`multiply`
+   :ocv:func:`multiply`
 
 
 .. index:: gpu::divide
@@ -84,7 +84,7 @@ gpu::divide
 This function, in contrast to :ocv:func:`divide`, uses a round-down rounding mode.
 
 .. seealso:: 
-:ocv:func:`divide`
+   :ocv:func:`divide`
 
 
 
@@ -101,7 +101,7 @@ gpu::exp
     :param dst: Destination matrix with the same size and type as ``src``.
 
 .. seealso:: 
-:ocv:func:`exp`
+   :ocv:func:`exp`
 
 
 
@@ -138,7 +138,7 @@ gpu::absdiff
     :param dst: Destination matrix with the same size and type as ``src1``.
 
 .. seealso:: 
-:ocv:func:`absdiff`
+   :ocv:func:`absdiff`
 
 .. index:: gpu::compare
 
@@ -164,7 +164,7 @@ gpu::compare
             * **CMP_NE:** ``src1(.) != src2(.)``
 
 .. seealso:: 
-:ocv:func:`compare`
+  :ocv:func:`compare`
 
 
 .. index:: gpu::bitwise_not
@@ -276,7 +276,7 @@ gpu::min
     :param stream: Stream for the asynchronous version.
 
 .. seealso:: 
-:ocv:func:`min`
+   :ocv:func:`min`
 
 
 
@@ -303,4 +303,4 @@ gpu::max
     :param stream: Stream for the asynchronous version.
 
 .. seealso:: 
-:ocv:func:`max`
+   :ocv:func:`max`
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 7c1ebb786a..9ef46a477d 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -47,8 +47,8 @@
 #include "opencv2/core/core.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/objdetect/objdetect.hpp"
-#include "opencv2/gpu/devmem2d.hpp"
 #include "opencv2/features2d/features2d.hpp"
+#include "opencv2/gpu/gpumat.hpp"
 
 namespace cv
 {
@@ -124,6 +124,8 @@ namespace cv
             // Checks whether the GPU module can be run on the given device
             bool isCompatible() const;
 
+            int deviceID() const { return device_id_; }
+
         private:
             void query();
             void queryMemory(size_t& free_memory, size_t& total_memory) const;
@@ -141,188 +143,17 @@ namespace cv
         CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
         CV_EXPORTS void nppError( int err, const char *file, const int line, const char *func);
 
-        //////////////////////////////// GpuMat ////////////////////////////////
-        class Stream;
-        class CudaMem;
-
-        //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
-        class CV_EXPORTS GpuMat
-        {
-        public:
-            //! default constructor
-            GpuMat();
-            //! constructs GpuMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
-            GpuMat(int rows, int cols, int type);
-            GpuMat(Size size, int type);
-            //! constucts GpuMatrix and fills it with the specified value _s.
-            GpuMat(int rows, int cols, int type, const Scalar& s);
-            GpuMat(Size size, int type, const Scalar& s);
-            //! copy constructor
-            GpuMat(const GpuMat& m);
-
-            //! constructor for GpuMatrix headers pointing to user-allocated data
-            GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP);
-            GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP);
-
-            //! creates a matrix header for a part of the bigger matrix
-            GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange);
-            GpuMat(const GpuMat& m, const Rect& roi);
-
-            //! builds GpuMat from Mat. Perfom blocking upload to device.
-            explicit GpuMat (const Mat& m);
-
-            //! destructor - calls release()
-            ~GpuMat();
-
-            //! assignment operators
-            GpuMat& operator = (const GpuMat& m);
-            //! assignment operator. Perfom blocking upload to device.
-            GpuMat& operator = (const Mat& m);
-
-            //! returns lightweight DevMem2D_ structure for passing to nvcc-compiled code.
-            // Contains just image size, data ptr and step.
-            template <class T> operator DevMem2D_<T>() const;
-            template <class T> operator PtrStep_<T>() const;
-
-            //! pefroms blocking upload data to GpuMat.
-            void upload(const cv::Mat& m);
-
-            //! upload async
-            void upload(const CudaMem& m, Stream& stream);
-
-            //! downloads data from device to host memory. Blocking calls.
-            operator Mat() const;
-            void download(cv::Mat& m) const;
-
-            //! download async
-            void download(CudaMem& m, Stream& stream) const;
-
-            //! returns a new GpuMatrix header for the specified row
-            GpuMat row(int y) const;
-            //! returns a new GpuMatrix header for the specified column
-            GpuMat col(int x) const;
-            //! ... for the specified row span
-            GpuMat rowRange(int startrow, int endrow) const;
-            GpuMat rowRange(const Range& r) const;
-            //! ... for the specified column span
-            GpuMat colRange(int startcol, int endcol) const;
-            GpuMat colRange(const Range& r) const;
-
-            //! returns deep copy of the GpuMatrix, i.e. the data is copied
-            GpuMat clone() const;
-            //! copies the GpuMatrix content to "m".
-            // It calls m.create(this->size(), this->type()).
-            void copyTo( GpuMat& m ) const;
-            //! copies those GpuMatrix elements to "m" that are marked with non-zero mask elements.
-            void copyTo( GpuMat& m, const GpuMat& mask ) const;
-            //! converts GpuMatrix to another datatype with optional scalng. See cvConvertScale.
-            void convertTo( GpuMat& m, int rtype, double alpha=1, double beta=0 ) const;
-
-            void assignTo( GpuMat& m, int type=-1 ) const;
-
-            //! sets every GpuMatrix element to s
-            GpuMat& operator = (const Scalar& s);
-            //! sets some of the GpuMatrix elements to s, according to the mask
-            GpuMat& setTo(const Scalar& s, const GpuMat& mask = GpuMat());
-            //! creates alternative GpuMatrix header for the same data, with different
-            // number of channels and/or different number of rows. see cvReshape.
-            GpuMat reshape(int cn, int rows = 0) const;
-
-            //! allocates new GpuMatrix data unless the GpuMatrix already has specified size and type.
-            // previous data is unreferenced if needed.
-            void create(int rows, int cols, int type);
-            void create(Size size, int type);
-            //! decreases reference counter;
-            // deallocate the data when reference counter reaches 0.
-            void release();
-
-            //! swaps with other smart pointer
-            void swap(GpuMat& mat);
-
-            //! locates GpuMatrix header within a parent GpuMatrix. See below
-            void locateROI( Size& wholeSize, Point& ofs ) const;
-            //! moves/resizes the current GpuMatrix ROI inside the parent GpuMatrix.
-            GpuMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
-            //! extracts a rectangular sub-GpuMatrix
-            // (this is a generalized form of row, rowRange etc.)
-            GpuMat operator()( Range rowRange, Range colRange ) const;
-            GpuMat operator()( const Rect& roi ) const;
-
-            //! returns true iff the GpuMatrix data is continuous
-            // (i.e. when there are no gaps between successive rows).
-            // similar to CV_IS_GpuMat_CONT(cvGpuMat->type)
-            bool isContinuous() const;
-            //! returns element size in bytes,
-            // similar to CV_ELEM_SIZE(cvMat->type)
-            size_t elemSize() const;
-            //! returns the size of element channel in bytes.
-            size_t elemSize1() const;
-            //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
-            int type() const;
-            //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
-            int depth() const;
-            //! returns element type, similar to CV_MAT_CN(cvMat->type)
-            int channels() const;
-            //! returns step/elemSize1()
-            size_t step1() const;
-            //! returns GpuMatrix size:
-            // width == number of columns, height == number of rows
-            Size size() const;
-            //! returns true if GpuMatrix data is NULL
-            bool empty() const;
-
-            //! returns pointer to y-th row
-            uchar* ptr(int y = 0);
-            const uchar* ptr(int y = 0) const;
-
-            //! template version of the above method
-            template<typename _Tp> _Tp* ptr(int y = 0);
-            template<typename _Tp> const _Tp* ptr(int y = 0) const;
-
-            //! matrix transposition
-            GpuMat t() const;
-
-            /*! includes several bit-fields:
-            - the magic signature
-            - continuity flag
-            - depth
-            - number of channels
-            */
-            int flags;
-            //! the number of rows and columns
-            int rows, cols;
-            //! a distance between successive rows in bytes; includes the gap if any
-            size_t step;
-            //! pointer to the data
-            uchar* data;
-
-            //! pointer to the reference counter;
-            // when GpuMatrix points to user-allocated data, the pointer is NULL
-            int* refcount;
-
-            //! helper fields used in locateROI and adjustROI
-            uchar* datastart;
-            uchar* dataend;
-        };
-
-//#define TemplatedGpuMat // experimental now, deprecated to use
-#ifdef TemplatedGpuMat
-    #include "GpuMat_BetaDeprecated.hpp"
-#endif
-
-        //! Creates continuous GPU matrix
-        CV_EXPORTS void createContinuous(int rows, int cols, int type, GpuMat& m);
-
-        //! Ensures that size of the given matrix is not less than (rows, cols) size
-        //! and matrix type is match specified one too
-        CV_EXPORTS void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m);
-
         //////////////////////////////// CudaMem ////////////////////////////////
         // CudaMem is limited cv::Mat with page locked memory allocation.
         // Page locked memory is only needed for async and faster coping to GPU.
         // It is convertable to cv::Mat header without reference counting
         // so you can use it with other opencv functions.
 
+        // Page-locks the matrix m memory and maps it for the device(s)
+        CV_EXPORTS void registerPageLocked(Mat& m);
+        // Unmaps the memory of matrix m, and makes it pageable again.
+        CV_EXPORTS void unregisterPageLocked(Mat& m);
+
         class CV_EXPORTS CudaMem
         {
         public:
@@ -439,372 +270,7 @@ namespace cv
             
             explicit Stream(Impl* impl);
         };
-
-
-        ////////////////////////////// Arithmetics ///////////////////////////////////
-
-        //! transposes the matrix
-        //! supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)
-        CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! reverses the order of the rows, columns or both in a matrix
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream = Stream::Null());
-
-        //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
-        //! destination array will have the depth type as lut and the same channels number as source
-        //! supports CV_8UC1, CV_8UC3 types
-        CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! makes multi-channel array out of several single-channel arrays
-        CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! makes multi-channel array out of several single-channel arrays
-        CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! copies each plane of a multi-channel array to a dedicated array
-        CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());
-
-        //! copies each plane of a multi-channel array to a dedicated array
-        CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
-
-        //! computes magnitude of complex (x(i).re, x(i).im) vector
-        //! supports only CV_32FC2 type
-        CV_EXPORTS void magnitude(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes squared magnitude of complex (x(i).re, x(i).im) vector
-        //! supports only CV_32FC2 type
-        CV_EXPORTS void magnitudeSqr(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes magnitude of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes squared magnitude of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
-
-        //! computes angle (angle(i)) of each (x(i), y(i)) vector
-        //! supports only floating-point source
-        CV_EXPORTS void phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
-
-        //! converts Cartesian coordinates to polar
-        //! supports only floating-point source
-        CV_EXPORTS void cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
-
-        //! converts polar coordinates to Cartesian
-        //! supports only floating-point source
-        CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false, Stream& stream = Stream::Null());
-
-
-        //////////////////////////// Per-element operations ////////////////////////////////////
-
-        //! adds one matrix to another (c = a + b)
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
-        CV_EXPORTS void add(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! adds scalar to a matrix (c = a + s)
-        //! supports CV_32FC1 and CV_32FC2 type
-        CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
-
-        //! subtracts one matrix from another (c = a - b)
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
-        CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! subtracts scalar from a matrix (c = a - s)
-        //! supports CV_32FC1 and CV_32FC2 type
-        CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
-
-        //! computes element-wise product of the two arrays (c = a * b)
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
-        CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! multiplies matrix to a scalar (c = a * s)
-        //! supports CV_32FC1 and CV_32FC2 type
-        CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
-
-        //! computes element-wise quotient of the two arrays (c = a / b)
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
-        CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! computes element-wise quotient of matrix and scalar (c = a / s)
-        //! supports CV_32FC1 and CV_32FC2 type
-        CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
-
-        //! computes exponent of each matrix element (b = e**a)
-        //! supports only CV_32FC1 type
-        CV_EXPORTS void exp(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
-
-        //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
-        //! supports only CV_32FC1 type
-        CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
-
-        //! computes element-wise absolute difference of two arrays (c = abs(a - b))
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
-        CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
-        //! computes element-wise absolute difference of array and scalar (c = abs(a - s))
-        //! supports only CV_32FC1 type
-        CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c, Stream& stream = Stream::Null());
-
-        //! compares elements of two arrays (c = a <cmpop> b)
-        //! supports CV_8UC4, CV_32FC1 types
-        CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
-
-        //! performs per-elements bit-wise inversion
-        CV_EXPORTS void bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
-
-        //! calculates per-element bit-wise disjunction of two arrays
-        CV_EXPORTS void bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
-
-        //! calculates per-element bit-wise conjunction of two arrays
-        CV_EXPORTS void bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
-
-        //! calculates per-element bit-wise "exclusive or" operation
-        CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
-
-        //! computes per-element minimum of two arrays (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! computes per-element minimum of array and scalar (dst = min(src1, src2))
-        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! computes per-element maximum of two arrays (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
-
-        //! computes per-element maximum of array and scalar (dst = max(src1, src2))
-        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
-
-
-        ////////////////////////////// Image processing //////////////////////////////
-
-        //! DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation.
-        //! supports CV_8UC1, CV_8UC3 source types and CV_32FC1 map type
-        CV_EXPORTS void remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap);
-
-        //! Does mean shift filtering on GPU.
-        CV_EXPORTS void meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
-
-        //! Does mean shift procedure on GPU.
-        CV_EXPORTS void meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
-
-        //! Does mean shift segmentation with elimination of small regions.
-        CV_EXPORTS void meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize,
-            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
-
-        //! Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV.
-        //! Supported types of input disparity: CV_8U, CV_16S.
-        //! Output disparity has CV_8UC4 type in BGRA format (alpha = 255).
-        CV_EXPORTS void drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, Stream& stream = Stream::Null());
-
-        //! Reprojects disparity image to 3D space.
-        //! Supports CV_8U and CV_16S types of input disparity.
-        //! The output is a 4-channel floating-point (CV_32FC4) matrix.
-        //! Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map.
-        //! Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.
-        CV_EXPORTS void reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, Stream& stream = Stream::Null());
-
-        //! converts image from one color space to another
-        CV_EXPORTS void cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0, Stream& stream = Stream::Null());
-
-        //! applies fixed threshold to the image
-        CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
-
-        //! resizes the image
-        //! Supports INTER_NEAREST, INTER_LINEAR
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! warps the image using affine transformation
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! warps the image using perspective transformation
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! rotate 8bit single or four channel image
-        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
-        //! supports CV_8UC1, CV_8UC4 types
-        CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
-
-        //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
-        //! supports CV_8UC1, CV_8UC4, CV_32SC1 and CV_32FC1 types
-        CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar(), Stream& stream = Stream::Null());
-
-        //! computes the integral image
-        //! sum will have CV_32S type, but will contain unsigned int values
-        //! supports only CV_8UC1 source type
-        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null());
-
-        //! buffered version
-        CV_EXPORTS void integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, Stream& stream = Stream::Null());
-
-        //! computes the integral image and integral for the squared image
-        //! sum will have CV_32S type, sqsum - CV32F type
-        //! supports only CV_8UC1 source type
-        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum, Stream& stream = Stream::Null());
-
-        //! computes squared integral image
-        //! result matrix will have 64F type, but will contain 64U values
-        //! supports source images of 8UC1 type only
-        CV_EXPORTS void sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null());
-
-        //! computes vertical sum, supports only CV_32FC1 images
-        CV_EXPORTS void columnSum(const GpuMat& src, GpuMat& sum);
-
-        //! computes the standard deviation of integral images
-        //! supports only CV_32SC1 source type and CV_32FC1 sqr type
-        //! output will have CV_32FC1 type
-        CV_EXPORTS void rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null());
-
-        //! computes Harris cornerness criteria at each image pixel
-        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101);
-
-        //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
-        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
-
-        //! performs per-element multiplication of two full (not packed) Fourier spectrums
-        //! supports 32FC2 matrixes only (interleaved format)
-        CV_EXPORTS void mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false);
-
-        //! performs per-element multiplication of two full (not packed) Fourier spectrums
-        //! supports 32FC2 matrixes only (interleaved format)
-        CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, 
-                                             float scale, bool conjB=false);
-
-        //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
-        //! Param dft_size is the size of DFT transform.
-        //! 
-        //! If the source matrix is not continous, then additional copy will be done,
-        //! so to avoid copying ensure the source matrix is continous one. If you want to use
-        //! preallocated output ensure it is continuous too, otherwise it will be reallocated.
-        //!
-        //! Being implemented via CUFFT real-to-complex transform result contains only non-redundant values
-        //! in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
-        //!
-        //! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
-        CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0);
-
-        //! computes convolution (or cross-correlation) of two images using discrete Fourier transform
-        //! supports source images of 32FC1 type only
-        //! result matrix will have 32FC1 type
-        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, 
-                                 bool ccorr=false);
-
-        struct CV_EXPORTS ConvolveBuf;
-
-        //! buffered version
-        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, 
-                                 bool ccorr, ConvolveBuf& buf);
-
-        struct CV_EXPORTS ConvolveBuf
-        {
-            ConvolveBuf() {}
-            ConvolveBuf(Size image_size, Size templ_size) 
-                { create(image_size, templ_size); }
-            void create(Size image_size, Size templ_size);
-
-        private:
-            static Size estimateBlockSize(Size result_size, Size templ_size);
-            friend void convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&);
-
-            Size result_size;
-            Size block_size;
-            Size dft_size;
-            int spect_len;
-
-            GpuMat image_spect, templ_spect, result_spect;
-            GpuMat image_block, templ_block, result_data;
-        };
-
-        //! computes the proximity map for the raster template and the image where the template is searched for
-        CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method);
-
-        //! downsamples image
-        CV_EXPORTS void downsample(const GpuMat& src, GpuMat& dst, int k=2);
-
-        //! performs linear blending of two images
-        //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
-        CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
-            GpuMat& result, Stream& stream = Stream::Null());
-
-        ////////////////////////////// Matrix reductions //////////////////////////////
-
-        //! computes mean value and standard deviation of all or selected array elements
-        //! supports only CV_8UC1 type
-        CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
-
-        //! computes norm of array
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports all matrices except 64F
-        CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
-
-        //! computes norm of array
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports all matrices except 64F
-        CV_EXPORTS double norm(const GpuMat& src1, int normType, GpuMat& buf);
-
-        //! computes norm of the difference between two arrays
-        //! supports NORM_INF, NORM_L1, NORM_L2
-        //! supports only CV_8UC1 type
-        CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
-
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src);
-
-        //! computes sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
-
-        //! computes sum of array elements absolute values
-        //! supports only single channel images
-        CV_EXPORTS Scalar absSum(const GpuMat& src);
-
-        //! computes sum of array elements absolute values
-        //! supports only single channel images
-        CV_EXPORTS Scalar absSum(const GpuMat& src, GpuMat& buf);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src);
-
-        //! computes squared sum of array elements
-        //! supports only single channel images
-        CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values
-        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
-                                  const GpuMat& mask=GpuMat());
-
-        //! finds global minimum and maximum array elements and returns their values with locations
-        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
-                                  const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src);
-
-        //! counts non-zero array elements
-        CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
-
-
-        ///////////////////////////// Calibration 3D //////////////////////////////////
-
-        CV_EXPORTS void transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
-                                        GpuMat& dst, Stream& stream = Stream::Null());
-
-        CV_EXPORTS void projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
-                                      const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, 
-                                      Stream& stream = Stream::Null());
-
-        CV_EXPORTS void solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
-                                       const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false,
-                                       int num_iters=100, float max_dist=8.0, int min_inlier_count=100, 
-                                       vector<int>* inliers=NULL);
+        
 
         //////////////////////////////// Filter Engine ////////////////////////////////
 
@@ -990,6 +456,464 @@ namespace cv
         //! supports only ksize = 1 and ksize = 3
         CV_EXPORTS void Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1, Stream& stream = Stream::Null());
 
+
+        ////////////////////////////// Arithmetics ///////////////////////////////////
+
+        //! transposes the matrix
+        //! supports matrix with element size = 1, 4 and 8 bytes (CV_8UC1, CV_8UC4, CV_16UC2, CV_32FC1, etc)
+        CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! reverses the order of the rows, columns or both in a matrix
+        //! supports CV_8UC1, CV_8UC4 types
+        CV_EXPORTS void flip(const GpuMat& a, GpuMat& b, int flipCode, Stream& stream = Stream::Null());
+
+        //! transforms 8-bit unsigned integers using lookup table: dst(i)=lut(src(i))
+        //! destination array will have the depth type as lut and the same channels number as source
+        //! supports CV_8UC1, CV_8UC3 types
+        CV_EXPORTS void LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! makes multi-channel array out of several single-channel arrays
+        CV_EXPORTS void merge(const GpuMat* src, size_t n, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! makes multi-channel array out of several single-channel arrays
+        CV_EXPORTS void merge(const vector<GpuMat>& src, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! copies each plane of a multi-channel array to a dedicated array
+        CV_EXPORTS void split(const GpuMat& src, GpuMat* dst, Stream& stream = Stream::Null());
+
+        //! copies each plane of a multi-channel array to a dedicated array
+        CV_EXPORTS void split(const GpuMat& src, vector<GpuMat>& dst, Stream& stream = Stream::Null());
+
+        //! computes magnitude of complex (x(i).re, x(i).im) vector
+        //! supports only CV_32FC2 type
+        CV_EXPORTS void magnitude(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+        //! computes squared magnitude of complex (x(i).re, x(i).im) vector
+        //! supports only CV_32FC2 type
+        CV_EXPORTS void magnitudeSqr(const GpuMat& x, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+        //! computes magnitude of each (x(i), y(i)) vector
+        //! supports only floating-point source
+        CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+        //! computes squared magnitude of each (x(i), y(i)) vector
+        //! supports only floating-point source
+        CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, Stream& stream = Stream::Null());
+
+        //! computes angle (angle(i)) of each (x(i), y(i)) vector
+        //! supports only floating-point source
+        CV_EXPORTS void phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
+
+        //! converts Cartesian coordinates to polar
+        //! supports only floating-point source
+        CV_EXPORTS void cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees = false, Stream& stream = Stream::Null());
+
+        //! converts polar coordinates to Cartesian
+        //! supports only floating-point source
+        CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false, Stream& stream = Stream::Null());
+
+
+        //////////////////////////// Per-element operations ////////////////////////////////////
+
+        //! adds one matrix to another (c = a + b)
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
+        CV_EXPORTS void add(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+        //! adds scalar to a matrix (c = a + s)
+        //! supports CV_32FC1 and CV_32FC2 type
+        CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
+
+        //! subtracts one matrix from another (c = a - b)
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
+        CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+        //! subtracts scalar from a matrix (c = a - s)
+        //! supports CV_32FC1 and CV_32FC2 type
+        CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
+
+        //! computes element-wise product of the two arrays (c = a * b)
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
+        CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+        //! multiplies matrix to a scalar (c = a * s)
+        //! supports CV_32FC1 type
+        CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
+
+        //! computes element-wise quotient of the two arrays (c = a / b)
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
+        CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+        //! computes element-wise quotient of matrix and scalar (c = a / s)
+        //! supports CV_32FC1 type
+        CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c, Stream& stream = Stream::Null());
+
+        //! computes exponent of each matrix element (b = e**a)
+        //! supports only CV_32FC1 type
+        CV_EXPORTS void exp(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
+        
+        //! computes power of each matrix element:
+        //    (dst(i,j) = pow(     src(i,j) , power), if src.type() is integer
+        //    (dst(i,j) = pow(fabs(src(i,j)), power), otherwise
+        //! supports all, except depth == CV_64F
+        CV_EXPORTS void pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a))
+        //! supports only CV_32FC1 type
+        CV_EXPORTS void log(const GpuMat& a, GpuMat& b, Stream& stream = Stream::Null());
+
+        //! computes element-wise absolute difference of two arrays (c = abs(a - b))
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types
+        CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c, Stream& stream = Stream::Null());
+        //! computes element-wise absolute difference of array and scalar (c = abs(a - s))
+        //! supports only CV_32FC1 type
+        CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c, Stream& stream = Stream::Null());
+
+        //! compares elements of two arrays (c = a <cmpop> b)
+        //! supports CV_8UC4, CV_32FC1 types
+        CV_EXPORTS void compare(const GpuMat& a, const GpuMat& b, GpuMat& c, int cmpop, Stream& stream = Stream::Null());
+
+        //! performs per-elements bit-wise inversion
+        CV_EXPORTS void bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+
+        //! calculates per-element bit-wise disjunction of two arrays
+        CV_EXPORTS void bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+
+        //! calculates per-element bit-wise conjunction of two arrays
+        CV_EXPORTS void bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+
+        //! calculates per-element bit-wise "exclusive or" operation
+        CV_EXPORTS void bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat(), Stream& stream = Stream::Null());
+
+        //! computes per-element minimum of two arrays (dst = min(src1, src2))
+        CV_EXPORTS void min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! computes per-element minimum of array and scalar (dst = min(src1, src2))
+        CV_EXPORTS void min(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! computes per-element maximum of two arrays (dst = max(src1, src2))
+        CV_EXPORTS void max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! computes per-element maximum of array and scalar (dst = max(src1, src2))
+        CV_EXPORTS void max(const GpuMat& src1, double src2, GpuMat& dst, Stream& stream = Stream::Null());
+
+
+        ////////////////////////////// Image processing //////////////////////////////
+
+        //! DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation.
+        //! supports CV_8UC1, CV_8UC3 source types and CV_32FC1 map type
+        CV_EXPORTS void remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap);
+
+        //! Does mean shift filtering on GPU.
+        CV_EXPORTS void meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
+            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
+
+        //! Does mean shift procedure on GPU.
+        CV_EXPORTS void meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr,
+            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
+
+        //! Does mean shift segmentation with elimination of small regions.
+        CV_EXPORTS void meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize,
+            TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1));
+
+        //! Does coloring of disparity image: [0..ndisp) -> [0..240, 1, 1] in HSV.
+        //! Supported types of input disparity: CV_8U, CV_16S.
+        //! Output disparity has CV_8UC4 type in BGRA format (alpha = 255).
+        CV_EXPORTS void drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, Stream& stream = Stream::Null());
+
+        //! Reprojects disparity image to 3D space.
+        //! Supports CV_8U and CV_16S types of input disparity.
+        //! The output is a 4-channel floating-point (CV_32FC4) matrix.
+        //! Each element of this matrix will contain the 3D coordinates of the point (x,y,z,1), computed from the disparity map.
+        //! Q is the 4x4 perspective transformation matrix that can be obtained with cvStereoRectify.
+        CV_EXPORTS void reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, Stream& stream = Stream::Null());
+
+        //! converts image from one color space to another
+        CV_EXPORTS void cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0, Stream& stream = Stream::Null());
+
+        //! applies fixed threshold to the image
+        CV_EXPORTS double threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, Stream& stream = Stream::Null());
+
+        //! resizes the image
+        //! Supports INTER_NEAREST, INTER_LINEAR
+        //! supports CV_8UC1, CV_8UC4 types
+        CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
+
+        //! warps the image using affine transformation
+        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+        CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
+
+        //! warps the image using perspective transformation
+        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+        CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR, Stream& stream = Stream::Null());
+
+        //! builds plane warping maps
+        CV_EXPORTS void buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s, double dist,
+                                           GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+        //! builds cylindrical warping maps
+        CV_EXPORTS void buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s,
+                                                 GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+        //! builds spherical warping maps
+        CV_EXPORTS void buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s,
+                                               GpuMat& map_x, GpuMat& map_y, Stream& stream = Stream::Null());
+
+        //! rotate 8bit single or four channel image
+        //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC
+        //! supports CV_8UC1, CV_8UC4 types
+        CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR, Stream& stream = Stream::Null());
+
+        //! copies 2D array to a larger destination array and pads borders with user-specifiable constant
+        //! supports CV_8UC1, CV_8UC4, CV_32SC1 and CV_32FC1 types
+        CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar(), Stream& stream = Stream::Null());
+
+        //! computes the integral image
+        //! sum will have CV_32S type, but will contain unsigned int values
+        //! supports only CV_8UC1 source type
+        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, Stream& stream = Stream::Null());
+
+        //! buffered version
+        CV_EXPORTS void integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, Stream& stream = Stream::Null());
+
+        //! computes the integral image and integral for the squared image
+        //! sum will have CV_32S type, sqsum - CV32F type
+        //! supports only CV_8UC1 source type
+        CV_EXPORTS void integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum, Stream& stream = Stream::Null());
+
+        //! computes squared integral image
+        //! result matrix will have 64F type, but will contain 64U values
+        //! supports source images of 8UC1 type only
+        CV_EXPORTS void sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& stream = Stream::Null());
+
+        //! computes vertical sum, supports only CV_32FC1 images
+        CV_EXPORTS void columnSum(const GpuMat& src, GpuMat& sum);
+
+        //! computes the standard deviation of integral images
+        //! supports only CV_32SC1 source type and CV_32FC1 sqr type
+        //! output will have CV_32FC1 type
+        CV_EXPORTS void rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect, Stream& stream = Stream::Null());
+
+        //! computes Harris cornerness criteria at each image pixel
+        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101);
+        CV_EXPORTS void cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101);
+
+        //! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
+        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
+        CV_EXPORTS void cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType=BORDER_REFLECT101);
+
+        //! performs per-element multiplication of two full (not packed) Fourier spectrums
+        //! supports 32FC2 matrixes only (interleaved format)
+        CV_EXPORTS void mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false);
+
+        //! performs per-element multiplication of two full (not packed) Fourier spectrums
+        //! supports 32FC2 matrixes only (interleaved format)
+        CV_EXPORTS void mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, 
+                                             float scale, bool conjB=false);
+
+        //! Performs a forward or inverse discrete Fourier transform (1D or 2D) of floating point matrix.
+        //! Param dft_size is the size of DFT transform.
+        //! 
+        //! If the source matrix is not continous, then additional copy will be done,
+        //! so to avoid copying ensure the source matrix is continous one. If you want to use
+        //! preallocated output ensure it is continuous too, otherwise it will be reallocated.
+        //!
+        //! Being implemented via CUFFT real-to-complex transform result contains only non-redundant values
+        //! in CUFFT's format. Result as full complex matrix for such kind of transform cannot be retrieved.
+        //!
+        //! For complex-to-real transform it is assumed that the source matrix is packed in CUFFT's format.
+        CV_EXPORTS void dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0);
+
+        //! computes convolution (or cross-correlation) of two images using discrete Fourier transform
+        //! supports source images of 32FC1 type only
+        //! result matrix will have 32FC1 type
+        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, 
+                                 bool ccorr=false);
+
+        struct CV_EXPORTS ConvolveBuf;
+
+        //! buffered version
+        CV_EXPORTS void convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, 
+                                 bool ccorr, ConvolveBuf& buf);
+
+        struct CV_EXPORTS ConvolveBuf
+        {
+            ConvolveBuf() {}
+            ConvolveBuf(Size image_size, Size templ_size) 
+                { create(image_size, templ_size); }
+            void create(Size image_size, Size templ_size);
+
+        private:
+            static Size estimateBlockSize(Size result_size, Size templ_size);
+            friend void convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&);
+
+            Size result_size;
+            Size block_size;
+            Size dft_size;
+            int spect_len;
+
+            GpuMat image_spect, templ_spect, result_spect;
+            GpuMat image_block, templ_block, result_data;
+        };
+
+        //! computes the proximity map for the raster template and the image where the template is searched for
+        CV_EXPORTS void matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method);
+
+        //! downsamples image
+        CV_EXPORTS void downsample(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
+
+        //! upsamples image
+        CV_EXPORTS void upsample(const GpuMat& src, GpuMat &dst, Stream& stream = Stream::Null());
+
+        //! smoothes the source image and downsamples it
+        CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
+        
+        struct CV_EXPORTS PyrDownBuf;
+        
+        CV_EXPORTS void pyrDown(const GpuMat& src, GpuMat& dst, PyrDownBuf& buf, Stream& stream = Stream::Null());
+        
+        struct CV_EXPORTS PyrDownBuf
+        {
+            PyrDownBuf() : image_type(-1) {}
+            PyrDownBuf(Size image_size, int image_type_) : image_type(-1) { create(image_size, image_type_); }
+            void create(Size image_size, int image_type_);
+
+        private:
+            friend void pyrDown(const GpuMat&, GpuMat&, PyrDownBuf&, Stream& stream);
+
+            static Mat ker;
+            GpuMat buf;
+            Ptr<FilterEngine_GPU> filter;
+            int image_type;
+        };
+
+        //! upsamples the source image and then smoothes it
+        CV_EXPORTS void pyrUp(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
+
+        struct CV_EXPORTS PyrUpBuf;
+        
+        CV_EXPORTS void pyrUp(const GpuMat& src, GpuMat& dst, PyrUpBuf& buf, Stream& stream = Stream::Null());
+        
+        struct CV_EXPORTS PyrUpBuf
+        {
+            PyrUpBuf() : image_type(-1) {}
+            PyrUpBuf(Size image_size, int image_type_) : image_type(-1) { create(image_size, image_type_); }
+            void create(Size image_size, int image_type_);
+
+        private:
+            friend void pyrUp(const GpuMat&, GpuMat&, PyrUpBuf&, Stream& stream);
+
+            static Mat ker;
+            GpuMat buf;
+            Ptr<FilterEngine_GPU> filter;
+            int image_type;
+        };
+
+        //! performs linear blending of two images
+        //! to avoid accuracy errors sum of weigths shouldn't be very close to zero
+        CV_EXPORTS void blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
+            GpuMat& result, Stream& stream = Stream::Null());
+
+        
+        struct CV_EXPORTS CannyBuf;
+        
+        CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
+        CV_EXPORTS void Canny(const GpuMat& image, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
+        CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
+        CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
+
+        struct CV_EXPORTS CannyBuf
+        {
+            CannyBuf() {}
+            explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);}
+            CannyBuf(const GpuMat& dx_, const GpuMat& dy_);
+
+            void create(const Size& image_size, int apperture_size = 3);
+            
+            void release();
+
+            GpuMat dx, dy;
+            GpuMat dx_buf, dy_buf;
+            GpuMat edgeBuf;
+            GpuMat trackBuf1, trackBuf2;
+            Ptr<FilterEngine_GPU> filterDX, filterDY;
+        };
+
+        ////////////////////////////// Matrix reductions //////////////////////////////
+
+        //! computes mean value and standard deviation of all or selected array elements
+        //! supports only CV_8UC1 type
+        CV_EXPORTS void meanStdDev(const GpuMat& mtx, Scalar& mean, Scalar& stddev);
+
+        //! computes norm of array
+        //! supports NORM_INF, NORM_L1, NORM_L2
+        //! supports all matrices except 64F
+        CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2);
+
+        //! computes norm of array
+        //! supports NORM_INF, NORM_L1, NORM_L2
+        //! supports all matrices except 64F
+        CV_EXPORTS double norm(const GpuMat& src1, int normType, GpuMat& buf);
+
+        //! computes norm of the difference between two arrays
+        //! supports NORM_INF, NORM_L1, NORM_L2
+        //! supports only CV_8UC1 type
+        CV_EXPORTS double norm(const GpuMat& src1, const GpuMat& src2, int normType=NORM_L2);
+
+        //! computes sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sum(const GpuMat& src);
+
+        //! computes sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sum(const GpuMat& src, GpuMat& buf);
+
+        //! computes sum of array elements absolute values
+        //! supports only single channel images
+        CV_EXPORTS Scalar absSum(const GpuMat& src);
+
+        //! computes sum of array elements absolute values
+        //! supports only single channel images
+        CV_EXPORTS Scalar absSum(const GpuMat& src, GpuMat& buf);
+
+        //! computes squared sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sqrSum(const GpuMat& src);
+
+        //! computes squared sum of array elements
+        //! supports only single channel images
+        CV_EXPORTS Scalar sqrSum(const GpuMat& src, GpuMat& buf);
+
+        //! finds global minimum and maximum array elements and returns their values
+        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal=0, const GpuMat& mask=GpuMat());
+
+        //! finds global minimum and maximum array elements and returns their values
+        CV_EXPORTS void minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf);
+
+        //! finds global minimum and maximum array elements and returns their values with locations
+        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0,
+                                  const GpuMat& mask=GpuMat());
+
+        //! finds global minimum and maximum array elements and returns their values with locations
+        CV_EXPORTS void minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
+                                  const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf);
+
+        //! counts non-zero array elements
+        CV_EXPORTS int countNonZero(const GpuMat& src);
+
+        //! counts non-zero array elements
+        CV_EXPORTS int countNonZero(const GpuMat& src, GpuMat& buf);
+
+
+        ///////////////////////////// Calibration 3D //////////////////////////////////
+
+        CV_EXPORTS void transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
+                                        GpuMat& dst, Stream& stream = Stream::Null());
+
+        CV_EXPORTS void projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec,
+                                      const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, 
+                                      Stream& stream = Stream::Null());
+
+        CV_EXPORTS void solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
+                                       const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false,
+                                       int num_iters=100, float max_dist=8.0, int min_inlier_count=100, 
+                                       vector<int>* inliers=NULL);
+
         //////////////////////////////// Image Labeling ////////////////////////////////
 
         //!performs labeling via graph cuts
@@ -1003,22 +927,36 @@ namespace cv
         //! Supports CV_8UC1, CV_16UC1 and CV_16SC1 source types.
         //! Output hist will have one row and histSize cols and CV_32SC1 type.
         CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
+        CV_EXPORTS void histEven(const GpuMat& src, GpuMat& hist, GpuMat& buf, int histSize, int lowerLevel, int upperLevel, Stream& stream = Stream::Null());
         //! Calculates histogram with evenly distributed bins for four-channel source.
         //! All channels of source are processed separately.
         //! Supports CV_8UC4, CV_16UC4 and CV_16SC4 source types.
         //! Output hist[i] will have one row and histSize[i] cols and CV_32SC1 type.
         CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
+        CV_EXPORTS void histEven(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream = Stream::Null());
         //! Calculates histogram with bins determined by levels array.
         //! levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
         //! Supports CV_8UC1, CV_16UC1, CV_16SC1 and CV_32FC1 source types.
         //! Output hist will have one row and (levels.cols-1) cols and CV_32SC1 type.
         CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, Stream& stream = Stream::Null());
+        CV_EXPORTS void histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream = Stream::Null());
         //! Calculates histogram with bins determined by levels array.
         //! All levels must have one row and CV_32SC1 type if source has integer type or CV_32FC1 otherwise.
         //! All channels of source are processed separately.
         //! Supports CV_8UC4, CV_16UC4, CV_16SC4 and CV_32FC4 source types.
         //! Output hist[i] will have one row and (levels[i].cols-1) cols and CV_32SC1 type.
         CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], Stream& stream = Stream::Null());
+        CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, Stream& stream = Stream::Null());
+        
+        //! Calculates histogram for 8u one channel image
+        //! Output hist will have one row, 256 cols and CV32SC1 type.
+        CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, Stream& stream = Stream::Null());
+        CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
+        
+        //! normalizes the grayscale image brightness and contrast by normalizing its histogram
+        CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
+        CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream = Stream::Null());
+        CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
 
         //////////////////////////////// StereoBM_GPU ////////////////////////////////
 
@@ -1321,8 +1259,10 @@ namespace cv
                 GpuMat& trainIdx, GpuMat& distance,
                 const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
 
-            // Download trainIdx and distance to CPU vector with DMatch
+            // Download trainIdx and distance and convert it to CPU vector with DMatch
             static void matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector<DMatch>& matches);
+            // Convert trainIdx and distance to vector with DMatch
+            static void matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches);
 
             // Find one best match for each query descriptor.
             void match(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector<DMatch>& matches,
@@ -1340,13 +1280,13 @@ namespace cv
                 GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance,
                 const GpuMat& maskCollection, Stream& stream = Stream::Null());
 
-            // Download trainIdx, imgIdx and distance to CPU vector with DMatch
-            static void matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
-                std::vector<DMatch>& matches);
+            // Download trainIdx, imgIdx and distance and convert it to vector with DMatch
+            static void matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, std::vector<DMatch>& matches);
+            // Convert trainIdx, imgIdx and distance to vector with DMatch
+            static void matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches);
 
             // Find one best match from train collection for each query descriptor.
-            void match(const GpuMat& queryDescs, std::vector<DMatch>& matches,
-                const std::vector<GpuMat>& masks = std::vector<GpuMat>());
+            void match(const GpuMat& queryDescs, std::vector<DMatch>& matches, const std::vector<GpuMat>& masks = std::vector<GpuMat>());
 
             // Find k best matches for each query descriptor (in increasing order of distances).
             // trainIdx.at<int>(queryIdx, i) will contain index of i'th best trains (i < k).
@@ -1358,12 +1298,15 @@ namespace cv
             void knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs,
                 GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
 
-            // Download trainIdx and distance to CPU vector with DMatch
+            // Download trainIdx and distance and convert it to vector with DMatch
             // compactResult is used when mask is not empty. If compactResult is false matches
             // vector will have the same size as queryDescriptors rows. If compactResult is true
             // matches vector will not contain matches for fully masked out query descriptors.
             static void knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
                 std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+            // Convert trainIdx and distance to vector with DMatch
+            static void knnMatchConvert(const Mat& trainIdx, const Mat& distance,
+                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
 
             // Find k best matches for each query descriptor (in increasing order of distances).
             // compactResult is used when mask is not empty. If compactResult is false matches
@@ -1393,13 +1336,16 @@ namespace cv
                 GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance,
                 const GpuMat& mask = GpuMat(), Stream& stream = Stream::Null());
 
-            // Download trainIdx, nMatches and distance to CPU vector with DMatch.
+            // Download trainIdx, nMatches and distance and convert it to vector with DMatch.
             // matches will be sorted in increasing order of distances.
             // compactResult is used when mask is not empty. If compactResult is false matches
             // vector will have the same size as queryDescriptors rows. If compactResult is true
             // matches vector will not contain matches for fully masked out query descriptors.
             static void radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance,
                 std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
+            // Convert trainIdx, nMatches and distance to vector with DMatch.
+            static void radiusMatchConvert(const Mat& trainIdx, const Mat& nMatches, const Mat& distance,
+                std::vector< std::vector<DMatch> >& matches, bool compactResult = false);
 
             // Find best matches for each query descriptor which have distance less than maxDistance
             // in increasing order of distances).
@@ -1412,9 +1358,9 @@ namespace cv
             void radiusMatch(const GpuMat& queryDescs, std::vector< std::vector<DMatch> >& matches, float maxDistance,
                 const std::vector<GpuMat>& masks = std::vector<GpuMat>(), bool compactResult = false);
 
-        private:
             DistType distType;
 
+        private:
             std::vector<GpuMat> trainDescCollection;
         };
 
@@ -1529,6 +1475,8 @@ namespace cv
             void operator()(const GpuMat& img, const GpuMat& mask, std::vector<KeyPoint>& keypoints, std::vector<float>& descriptors, 
                 bool useProvidedKeypoints = false);
 
+            void releaseMemory();
+
             //! max keypoints = min(keypointsRatio * img.size().area(), 65535)
             float keypointsRatio;
 
diff --git a/modules/gpu/include/opencv2/gpu/gpumat.hpp b/modules/gpu/include/opencv2/gpu/gpumat.hpp
new file mode 100644
index 0000000000..8ce456a93d
--- /dev/null
+++ b/modules/gpu/include/opencv2/gpu/gpumat.hpp
@@ -0,0 +1,274 @@
+/*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 GpuMaterials 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_GPUMAT_HPP__
+#define __OPENCV_GPUMAT_HPP__
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/gpu/devmem2d.hpp"
+
+namespace cv { namespace gpu
+{
+    class Stream;
+    class CudaMem;
+
+    //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
+    class CV_EXPORTS GpuMat
+    {
+    public:
+        //! default constructor
+        GpuMat();
+        //! constructs GpuMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
+        GpuMat(int rows, int cols, int type);
+        GpuMat(Size size, int type);
+        //! constucts GpuMatrix and fills it with the specified value _s.
+        GpuMat(int rows, int cols, int type, const Scalar& s);
+        GpuMat(Size size, int type, const Scalar& s);
+        //! copy constructor
+        GpuMat(const GpuMat& m);
+
+        //! constructor for GpuMatrix headers pointing to user-allocated data
+        GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP);
+        GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP);
+
+        //! creates a matrix header for a part of the bigger matrix
+        GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange);
+        GpuMat(const GpuMat& m, const Rect& roi);
+
+        //! builds GpuMat from Mat. Perfom blocking upload to device.
+        explicit GpuMat (const Mat& m);
+
+        //! destructor - calls release()
+        ~GpuMat();
+
+        //! assignment operators
+        GpuMat& operator = (const GpuMat& m);
+        //! assignment operator. Perfom blocking upload to device.
+        GpuMat& operator = (const Mat& m);
+
+        //! returns lightweight DevMem2D_ structure for passing to nvcc-compiled code.
+        // Contains just image size, data ptr and step.
+        template <class T> operator DevMem2D_<T>() const;
+        template <class T> operator PtrStep_<T>() const;
+
+        //! pefroms blocking upload data to GpuMat.
+        void upload(const cv::Mat& m);
+
+        //! upload async
+        void upload(const CudaMem& m, Stream& stream);
+
+        //! downloads data from device to host memory. Blocking calls.
+        operator Mat() const;
+        void download(cv::Mat& m) const;
+
+        //! download async
+        void download(CudaMem& m, Stream& stream) const;
+
+        //! returns a new GpuMatrix header for the specified row
+        GpuMat row(int y) const;
+        //! returns a new GpuMatrix header for the specified column
+        GpuMat col(int x) const;
+        //! ... for the specified row span
+        GpuMat rowRange(int startrow, int endrow) const;
+        GpuMat rowRange(const Range& r) const;
+        //! ... for the specified column span
+        GpuMat colRange(int startcol, int endcol) const;
+        GpuMat colRange(const Range& r) const;
+
+        //! returns deep copy of the GpuMatrix, i.e. the data is copied
+        GpuMat clone() const;
+        //! copies the GpuMatrix content to "m".
+        // It calls m.create(this->size(), this->type()).
+        void copyTo( GpuMat& m ) const;
+        //! copies those GpuMatrix elements to "m" that are marked with non-zero mask elements.
+        void copyTo( GpuMat& m, const GpuMat& mask ) const;
+        //! converts GpuMatrix to another datatype with optional scalng. See cvConvertScale.
+        void convertTo( GpuMat& m, int rtype, double alpha=1, double beta=0 ) const;
+
+        void assignTo( GpuMat& m, int type=-1 ) const;
+
+        //! sets every GpuMatrix element to s
+        GpuMat& operator = (const Scalar& s);
+        //! sets some of the GpuMatrix elements to s, according to the mask
+        GpuMat& setTo(const Scalar& s, const GpuMat& mask = GpuMat());
+        //! creates alternative GpuMatrix header for the same data, with different
+        // number of channels and/or different number of rows. see cvReshape.
+        GpuMat reshape(int cn, int rows = 0) const;
+
+        //! allocates new GpuMatrix data unless the GpuMatrix already has specified size and type.
+        // previous data is unreferenced if needed.
+        void create(int rows, int cols, int type);
+        void create(Size size, int type);
+        //! decreases reference counter;
+        // deallocate the data when reference counter reaches 0.
+        void release();
+
+        //! swaps with other smart pointer
+        void swap(GpuMat& mat);
+
+        //! locates GpuMatrix header within a parent GpuMatrix. See below
+        void locateROI( Size& wholeSize, Point& ofs ) const;
+        //! moves/resizes the current GpuMatrix ROI inside the parent GpuMatrix.
+        GpuMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
+        //! extracts a rectangular sub-GpuMatrix
+        // (this is a generalized form of row, rowRange etc.)
+        GpuMat operator()( Range rowRange, Range colRange ) const;
+        GpuMat operator()( const Rect& roi ) const;
+
+        //! returns true iff the GpuMatrix data is continuous
+        // (i.e. when there are no gaps between successive rows).
+        // similar to CV_IS_GpuMat_CONT(cvGpuMat->type)
+        bool isContinuous() const;
+        //! returns element size in bytes,
+        // similar to CV_ELEM_SIZE(cvMat->type)
+        size_t elemSize() const;
+        //! returns the size of element channel in bytes.
+        size_t elemSize1() const;
+        //! returns element type, similar to CV_MAT_TYPE(cvMat->type)
+        int type() const;
+        //! returns element type, similar to CV_MAT_DEPTH(cvMat->type)
+        int depth() const;
+        //! returns element type, similar to CV_MAT_CN(cvMat->type)
+        int channels() const;
+        //! returns step/elemSize1()
+        size_t step1() const;
+        //! returns GpuMatrix size:
+        // width == number of columns, height == number of rows
+        Size size() const;
+        //! returns true if GpuMatrix data is NULL
+        bool empty() const;
+
+        //! returns pointer to y-th row
+        uchar* ptr(int y = 0);
+        const uchar* ptr(int y = 0) const;
+
+        //! template version of the above method
+        template<typename _Tp> _Tp* ptr(int y = 0);
+        template<typename _Tp> const _Tp* ptr(int y = 0) const;
+
+        //! matrix transposition
+        GpuMat t() const;
+
+        /*! includes several bit-fields:
+        - the magic signature
+        - continuity flag
+        - depth
+        - number of channels
+        */
+        int flags;
+        //! the number of rows and columns
+        int rows, cols;
+        //! a distance between successive rows in bytes; includes the gap if any
+        size_t step;
+        //! pointer to the data
+        uchar* data;
+
+        //! pointer to the reference counter;
+        // when GpuMatrix points to user-allocated data, the pointer is NULL
+        int* refcount;
+
+        //! helper fields used in locateROI and adjustROI
+        uchar* datastart;
+        uchar* dataend;
+    };
+
+    //! Creates continuous GPU matrix
+    CV_EXPORTS void createContinuous(int rows, int cols, int type, GpuMat& m);
+    CV_EXPORTS GpuMat createContinuous(int rows, int cols, int type);
+    CV_EXPORTS void createContinuous(Size size, int type, GpuMat& m);
+    CV_EXPORTS GpuMat createContinuous(Size size, int type);
+
+    //! Ensures that size of the given matrix is not less than (rows, cols) size
+    //! and matrix type is match specified one too
+    CV_EXPORTS void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m);
+    CV_EXPORTS void ensureSizeIsEnough(Size size, int type, GpuMat& m);
+
+    ////////////////////////////////////////////////////////////////////////
+    //////////////////////////////// GpuMat ////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////
+
+    inline GpuMat::GpuMat() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) {}
+
+    inline GpuMat::GpuMat(int rows_, int cols_, int type_) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+    {
+        if (rows_ > 0 && cols_ > 0)
+            create(rows_, cols_, type_);
+    }
+
+    inline GpuMat::~GpuMat() { release(); }
+
+    template <class T> inline GpuMat::operator DevMem2D_<T>() const { return DevMem2D_<T>(rows, cols, (T*)data, step); }
+    template <class T> inline GpuMat::operator PtrStep_<T>() const { return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this)); }
+
+    inline GpuMat GpuMat::clone() const
+    {
+        GpuMat m;
+        copyTo(m);
+        return m;
+    }
+
+    inline void GpuMat::assignTo(GpuMat& m, int type) const
+    {
+        if( type < 0 )
+            m = *this;
+        else
+            convertTo(m, type);
+    }
+
+    inline size_t GpuMat::step1() const { return step/elemSize1(); }
+
+    inline bool GpuMat::empty() const { return data == 0; }
+
+    template<typename _Tp> inline _Tp* GpuMat::ptr(int y)
+    {
+        return (_Tp*)ptr(y);
+    }
+
+    template<typename _Tp> inline const _Tp* GpuMat::ptr(int y) const
+    {
+        return (const _Tp*)ptr(y);
+    }
+
+    inline void swap(GpuMat& a, GpuMat& b) { a.swap(b); }
+}}
+
+#endif // __OPENCV_GPUMAT_HPP__
diff --git a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp b/modules/gpu/include/opencv2/gpu/matrix_operations.hpp
index 7af0907824..e8bb9167b7 100644
--- a/modules/gpu/include/opencv2/gpu/matrix_operations.hpp
+++ b/modules/gpu/include/opencv2/gpu/matrix_operations.hpp
@@ -48,328 +48,6 @@ namespace cv
 
 namespace gpu
 {
-
-////////////////////////////////////////////////////////////////////////
-//////////////////////////////// GpuMat ////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-inline GpuMat::GpuMat() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) {}
-
-inline GpuMat::GpuMat(int _rows, int _cols, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-{
-    if( _rows > 0 && _cols > 0 )
-        create( _rows, _cols, _type );
-}
-
-inline GpuMat::GpuMat(Size _size, int _type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-{
-    if( _size.height > 0 && _size.width > 0 )
-        create( _size.height, _size.width, _type );
-}
-
-inline GpuMat::GpuMat(int _rows, int _cols, int _type, const Scalar& _s)
-    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-{
-    if(_rows > 0 && _cols > 0)
-    {
-        create(_rows, _cols, _type);
-        *this = _s;
-    }
-}
-
-inline GpuMat::GpuMat(Size _size, int _type, const Scalar& _s)
-    : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
-{
-    if( _size.height > 0 && _size.width > 0 )
-    {
-        create( _size.height, _size.width, _type );
-        *this = _s;
-    }
-}
-
-inline GpuMat::GpuMat(const GpuMat& m)
-    : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend)
-{
-    if( refcount )
-        CV_XADD(refcount, 1);
-}
-
-inline GpuMat::GpuMat(int _rows, int _cols, int _type, void* _data, size_t _step)
-    : flags(Mat::MAGIC_VAL + (_type & TYPE_MASK)), rows(_rows), cols(_cols), step(_step), data((uchar*)_data), refcount(0),
-    datastart((uchar*)_data), dataend((uchar*)_data)
-{
-    size_t minstep = cols*elemSize();
-    if( step == Mat::AUTO_STEP )
-    {
-        step = minstep;
-        flags |= Mat::CONTINUOUS_FLAG;
-    }
-    else
-    {
-        if( rows == 1 ) step = minstep;
-        CV_DbgAssert( step >= minstep );
-        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
-    }
-    dataend += step*(rows-1) + minstep;
-}
-
-inline GpuMat::GpuMat(Size _size, int _type, void* _data, size_t _step)
-    : flags(Mat::MAGIC_VAL + (_type & TYPE_MASK)), rows(_size.height), cols(_size.width),
-    step(_step), data((uchar*)_data), refcount(0),
-    datastart((uchar*)_data), dataend((uchar*)_data)
-{
-    size_t minstep = cols*elemSize();
-    if( step == Mat::AUTO_STEP )
-    {
-        step = minstep;
-        flags |= Mat::CONTINUOUS_FLAG;
-    }
-    else
-    {
-        if( rows == 1 ) step = minstep;
-        CV_DbgAssert( step >= minstep );
-        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
-    }
-    dataend += step*(rows-1) + minstep;
-}
-
-
-inline GpuMat::GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange)
-{
-    flags = m.flags;
-    step = m.step; refcount = m.refcount;
-    data = m.data; datastart = m.datastart; dataend = m.dataend;
-
-    if( rowRange == Range::all() )
-        rows = m.rows;
-    else
-    {
-        CV_Assert( 0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows );
-        rows = rowRange.size();
-        data += step*rowRange.start;
-    }
-
-    if( colRange == Range::all() )
-        cols = m.cols;
-    else
-    {
-        CV_Assert( 0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols );
-        cols = colRange.size();
-        data += colRange.start*elemSize();
-        flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
-    }
-
-    if( rows == 1 )
-        flags |= Mat::CONTINUOUS_FLAG;
-
-    if( refcount )
-        CV_XADD(refcount, 1);
-    if( rows <= 0 || cols <= 0 )
-        rows = cols = 0;
-}
-
-inline GpuMat::GpuMat(const GpuMat& m, const Rect& roi)
-    : flags(m.flags), rows(roi.height), cols(roi.width),
-    step(m.step), data(m.data + roi.y*step), refcount(m.refcount),
-    datastart(m.datastart), dataend(m.dataend)
-{
-    flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
-    data += roi.x*elemSize();
-    CV_Assert( 0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols &&
-        0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows );
-    if( refcount )
-        CV_XADD(refcount, 1);
-    if( rows <= 0 || cols <= 0 )
-        rows = cols = 0;
-}
-
-inline GpuMat::GpuMat(const Mat& m)
-: flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) { upload(m); }
-
-inline GpuMat::~GpuMat() { release(); }
-
-inline GpuMat& GpuMat::operator = (const GpuMat& m)
-{
-    if( this != &m )
-    {
-        if( m.refcount )
-            CV_XADD(m.refcount, 1);
-        release();
-        flags = m.flags;
-        rows = m.rows; cols = m.cols;
-        step = m.step; data = m.data;
-        datastart = m.datastart; dataend = m.dataend;
-        refcount = m.refcount;
-    }
-    return *this;
-}
-
-inline GpuMat& GpuMat::operator = (const Mat& m) { upload(m); return *this; }
-
-template <class T> inline GpuMat::operator DevMem2D_<T>() const { return DevMem2D_<T>(rows, cols, (T*)data, step); }
-template <class T> inline GpuMat::operator PtrStep_<T>() const { return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this)); }
-
-//CPP: void GpuMat::upload(const Mat& m);
-
- inline GpuMat::operator Mat() const
- {
-     Mat m;
-     download(m);
-     return m;
- }
-
-//CPP void GpuMat::download(cv::Mat& m) const;
-
-inline GpuMat GpuMat::row(int y) const { return GpuMat(*this, Range(y, y+1), Range::all()); }
-inline GpuMat GpuMat::col(int x) const { return GpuMat(*this, Range::all(), Range(x, x+1)); }
-inline GpuMat GpuMat::rowRange(int startrow, int endrow) const { return GpuMat(*this, Range(startrow, endrow), Range::all()); }
-inline GpuMat GpuMat::rowRange(const Range& r) const { return GpuMat(*this, r, Range::all()); }
-inline GpuMat GpuMat::colRange(int startcol, int endcol) const { return GpuMat(*this, Range::all(), Range(startcol, endcol)); }
-inline GpuMat GpuMat::colRange(const Range& r) const { return GpuMat(*this, Range::all(), r); }
-
-inline GpuMat GpuMat::clone() const
-{
-    GpuMat m;
-    copyTo(m);
-    return m;
-}
-
-//CPP void GpuMat::copyTo( GpuMat& m ) const;
-//CPP void GpuMat::copyTo( GpuMat& m, const GpuMat& mask  ) const;
-//CPP void GpuMat::convertTo( GpuMat& m, int rtype, double alpha=1, double beta=0 ) const;
-
-inline void GpuMat::assignTo( GpuMat& m, int type ) const
-{
-    if( type < 0 )
-        m = *this;
-    else
-        convertTo(m, type);
-}
-
-//CPP GpuMat& GpuMat::operator = (const Scalar& s);
-//CPP GpuMat& GpuMat::setTo(const Scalar& s, const GpuMat& mask=GpuMat());
-//CPP GpuMat GpuMat::reshape(int _cn, int _rows=0) const;
-inline void GpuMat::create(Size _size, int _type) { create(_size.height, _size.width, _type); }
-//CPP void GpuMat::create(int _rows, int _cols, int _type);
-//CPP void GpuMat::release();
-
-inline void GpuMat::swap(GpuMat& b)
-{
-    std::swap( flags, b.flags );
-    std::swap( rows, b.rows ); std::swap( cols, b.cols );
-    std::swap( step, b.step ); std::swap( data, b.data );
-    std::swap( datastart, b.datastart );
-    std::swap( dataend, b.dataend );
-    std::swap( refcount, b.refcount );
-}
-
-inline void GpuMat::locateROI( Size& wholeSize, Point& ofs ) const
-{
-    size_t esz = elemSize(), minstep;
-    ptrdiff_t delta1 = data - datastart, delta2 = dataend - datastart;
-    CV_DbgAssert( step > 0 );
-    if( delta1 == 0 )
-        ofs.x = ofs.y = 0;
-    else
-    {
-        ofs.y = (int)(delta1/step);
-        ofs.x = (int)((delta1 - step*ofs.y)/esz);
-        CV_DbgAssert( data == datastart + ofs.y*step + ofs.x*esz );
-    }
-    minstep = (ofs.x + cols)*esz;
-    wholeSize.height = (int)((delta2 - minstep)/step + 1);
-    wholeSize.height = std::max(wholeSize.height, ofs.y + rows);
-    wholeSize.width = (int)((delta2 - step*(wholeSize.height-1))/esz);
-    wholeSize.width = std::max(wholeSize.width, ofs.x + cols);
-}
-
-inline GpuMat& GpuMat::adjustROI( int dtop, int dbottom, int dleft, int dright )
-{
-    Size wholeSize; Point ofs;
-    size_t esz = elemSize();
-    locateROI( wholeSize, ofs );
-    int row1 = std::max(ofs.y - dtop, 0), row2 = std::min(ofs.y + rows + dbottom, wholeSize.height);
-    int col1 = std::max(ofs.x - dleft, 0), col2 = std::min(ofs.x + cols + dright, wholeSize.width);
-    data += (row1 - ofs.y)*step + (col1 - ofs.x)*esz;
-    rows = row2 - row1; cols = col2 - col1;
-    if( esz*cols == step || rows == 1 )
-        flags |= Mat::CONTINUOUS_FLAG;
-    else
-        flags &= ~Mat::CONTINUOUS_FLAG;
-    return *this;
-}
-
-inline GpuMat GpuMat::operator()( Range rowRange, Range colRange ) const { return GpuMat(*this, rowRange, colRange); }
-inline GpuMat GpuMat::operator()( const Rect& roi ) const { return GpuMat(*this, roi); }
-
-inline bool GpuMat::isContinuous() const { return (flags & Mat::CONTINUOUS_FLAG) != 0; }
-inline size_t GpuMat::elemSize() const { return CV_ELEM_SIZE(flags); }
-inline size_t GpuMat::elemSize1() const { return CV_ELEM_SIZE1(flags); }
-inline int GpuMat::type() const { return CV_MAT_TYPE(flags); }
-inline int GpuMat::depth() const { return CV_MAT_DEPTH(flags); }
-inline int GpuMat::channels() const { return CV_MAT_CN(flags); }
-inline size_t GpuMat::step1() const { return step/elemSize1(); }
-inline Size GpuMat::size() const { return Size(cols, rows); }
-inline bool GpuMat::empty() const { return data == 0; }
-
-inline uchar* GpuMat::ptr(int y)
-{
-    CV_DbgAssert( (unsigned)y < (unsigned)rows );
-    return data + step*y;
-}
-
-inline const uchar* GpuMat::ptr(int y) const
-{
-    CV_DbgAssert( (unsigned)y < (unsigned)rows );
-    return data + step*y;
-}
-
-template<typename _Tp> inline _Tp* GpuMat::ptr(int y)
-{
-    CV_DbgAssert( (unsigned)y < (unsigned)rows );
-    return (_Tp*)(data + step*y);
-}
-
-template<typename _Tp> inline const _Tp* GpuMat::ptr(int y) const
-{
-    CV_DbgAssert( (unsigned)y < (unsigned)rows );
-    return (const _Tp*)(data + step*y);
-}
-
-inline GpuMat GpuMat::t() const
-{
-    GpuMat tmp;
-    transpose(*this, tmp);
-    return tmp;
-}
-
-static inline void swap( GpuMat& a, GpuMat& b ) { a.swap(b); }
-
-inline GpuMat createContinuous(int rows, int cols, int type)
-{
-    GpuMat m;
-    createContinuous(rows, cols, type, m);
-    return m;
-}
-
-inline void createContinuous(Size size, int type, GpuMat& m)
-{
-    createContinuous(size.height, size.width, type, m);
-}
-
-inline GpuMat createContinuous(Size size, int type)
-{
-    GpuMat m;
-    createContinuous(size, type, m);
-    return m;
-}
-
-inline void ensureSizeIsEnough(Size size, int type, GpuMat& m)
-{
-    ensureSizeIsEnough(size.height, size.width, type, m);
-}
-
-
 ///////////////////////////////////////////////////////////////////////
 //////////////////////////////// CudaMem ////////////////////////////////
 ///////////////////////////////////////////////////////////////////////
@@ -457,41 +135,6 @@ inline size_t CudaMem::step1() const { return step/elemSize1(); }
 inline Size CudaMem::size() const { return Size(cols, rows); }
 inline bool CudaMem::empty() const { return data == 0; }
 
-//////////////////////////////////////////////////////////////////////////////
-// Arithmetical operations
-
-inline GpuMat operator ~ (const GpuMat& src)
-{
-    GpuMat dst;
-    bitwise_not(src, dst);
-    return dst;
-}
-
-
-inline GpuMat operator | (const GpuMat& src1, const GpuMat& src2)
-{
-    GpuMat dst;
-    bitwise_or(src1, src2, dst);
-    return dst;
-}
-
-
-inline GpuMat operator & (const GpuMat& src1, const GpuMat& src2)
-{
-    GpuMat dst;
-    bitwise_and(src1, src2, dst);
-    return dst;
-}
-
-
-inline GpuMat operator ^ (const GpuMat& src1, const GpuMat& src2)
-{
-    GpuMat dst;
-    bitwise_xor(src1, src2, dst);
-    return dst;
-}
-
-
 } /* end of namespace gpu */
 
 } /* end of namespace cv */
diff --git a/modules/gpu/src/arithm.cpp b/modules/gpu/src/arithm.cpp
index 176eeb3025..67da283eb6 100644
--- a/modules/gpu/src/arithm.cpp
+++ b/modules/gpu/src/arithm.cpp
@@ -82,7 +82,8 @@ void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
         sz.width  = src.cols;
         sz.height = src.rows;
 
-        nppSafeCall( nppiTranspose_8u_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz) );		
+        nppSafeCall( nppiTranspose_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );		
     }
     else if (src.elemSize() == 4)
     {
@@ -92,8 +93,8 @@ void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
         sz.width  = src.cols;
         sz.height = src.rows;
 
-        nppSafeCall( nppiStTranspose_32u_C1R(const_cast<Ncv32u*>(src.ptr<Ncv32u>()), src.step, 
-            dst.ptr<Ncv32u>(), dst.step, sz) );
+        nppSafeCall( nppiStTranspose_32u_C1R(const_cast<Ncv32u*>(src.ptr<Ncv32u>()), static_cast<int>(src.step), 
+            dst.ptr<Ncv32u>(), static_cast<int>(dst.step), sz) );
     }
     else // if (src.elemSize() == 8)
     {
@@ -103,8 +104,8 @@ void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
         sz.width  = src.cols;
         sz.height = src.rows;
 
-        nppSafeCall( nppiStTranspose_64u_C1R(const_cast<Ncv64u*>(src.ptr<Ncv64u>()), src.step, 
-            dst.ptr<Ncv64u>(), dst.step, sz) );		
+        nppSafeCall( nppiStTranspose_64u_C1R(const_cast<Ncv64u*>(src.ptr<Ncv64u>()), static_cast<int>(src.step), 
+            dst.ptr<Ncv64u>(), static_cast<int>(dst.step), sz) );		
     }
 
     if (stream == 0)
@@ -130,14 +131,14 @@ void cv::gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode, Stream& s)
 
     if (src.type() == CV_8UC1)
     {
-        nppSafeCall( nppiMirror_8u_C1R(src.ptr<Npp8u>(), src.step,
-            dst.ptr<Npp8u>(), dst.step, sz,
+        nppSafeCall( nppiMirror_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz,
             (flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS))) );
     }
     else
     {
-        nppSafeCall( nppiMirror_8u_C4R(src.ptr<Npp8u>(), src.step,
-            dst.ptr<Npp8u>(), dst.step, sz,
+        nppSafeCall( nppiMirror_8u_C4R(src.ptr<Npp8u>(), static_cast<int>(src.step),
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz,
             (flipCode == 0 ? NPP_HORIZONTAL_AXIS : (flipCode > 0 ? NPP_VERTICAL_AXIS : NPP_BOTH_AXIS))) );
     }
 
@@ -187,7 +188,8 @@ void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& s)
 
     if (src.type() == CV_8UC1)
     {
-        nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, nppLut.ptr<Npp32s>(), lvls.pLevels, 256) );
+        nppSafeCall( nppiLUT_Linear_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, nppLut.ptr<Npp32s>(), lvls.pLevels, 256) );
     }
     else
     {
@@ -202,7 +204,8 @@ void cv::gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst, Stream& s)
             pValues3[1] = nppLut3[1].ptr<Npp32s>();
             pValues3[2] = nppLut3[2].ptr<Npp32s>();
         }
-        nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, pValues3, lvls.pLevels3, lvls.nValues3) );
+        nppSafeCall( nppiLUT_Linear_8u_C3R(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, pValues3, lvls.pLevels3, lvls.nValues3) );
     }
 
     if (stream == 0)
@@ -226,7 +229,7 @@ void cv::gpu::exp(const GpuMat& src, GpuMat& dst, Stream& s)
 
     NppStreamHandler h(stream);
 
-    nppSafeCall( nppiExp_32f_C1R(src.ptr<Npp32f>(), src.step, dst.ptr<Npp32f>(), dst.step, sz) );
+    nppSafeCall( nppiExp_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -249,7 +252,7 @@ void cv::gpu::log(const GpuMat& src, GpuMat& dst, Stream& s)
 
     NppStreamHandler h(stream);
 
-    nppSafeCall( nppiLn_32f_C1R(src.ptr<Npp32f>(), src.step, dst.ptr<Npp32f>(), dst.step, sz) );
+    nppSafeCall( nppiLn_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -274,7 +277,7 @@ namespace
 
         NppStreamHandler h(stream);
 
-        nppSafeCall( func(src.ptr<Npp32fc>(), src.step, dst.ptr<Npp32f>(), dst.step, sz) );
+        nppSafeCall( func(src.ptr<Npp32fc>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
 
         if (stream == 0)
             cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/brute_force_matcher.cpp b/modules/gpu/src/brute_force_matcher.cpp
index d8805a7f54..19521a2a64 100644
--- a/modules/gpu/src/brute_force_matcher.cpp
+++ b/modules/gpu/src/brute_force_matcher.cpp
@@ -56,17 +56,21 @@ bool cv::gpu::BruteForceMatcher_GPU_base::empty() const { throw_nogpu(); return
 bool cv::gpu::BruteForceMatcher_GPU_base::isMaskSupported() const { throw_nogpu(); return true; }
 void cv::gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat&, const GpuMat&, vector<DMatch>&) { throw_nogpu(); }
+void cv::gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat&, const Mat&, std::vector<DMatch>&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::match(const GpuMat&, const GpuMat&, vector<DMatch>&, const GpuMat&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::makeGpuCollection(GpuMat&, GpuMat&, const vector<GpuMat>&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::matchCollection(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector<DMatch>&) { throw_nogpu(); }
+void cv::gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat&, const Mat&, const Mat&, std::vector<DMatch>&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::match(const GpuMat&, std::vector<DMatch>&, const std::vector<GpuMat>&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, const GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_nogpu(); }
+void cv::gpu::BruteForceMatcher_GPU_base::knnMatchConvert(const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, int, const GpuMat&, bool) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, int, const std::vector<GpuMat>&, bool) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, GpuMat&, float, const GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat&, const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, bool) { throw_nogpu(); }
+void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat&, const Mat&, const Mat&, std::vector< std::vector<DMatch> >&, bool) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat&, const GpuMat&, std::vector< std::vector<DMatch> >&, float, const GpuMat&, bool) { throw_nogpu(); }
 void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat&, std::vector< std::vector<DMatch> >&, float, const std::vector<GpuMat>&, bool) { throw_nogpu(); }
 
@@ -203,8 +207,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat& queryDescs,
 
     const int nQuery = queryDescs.rows;
 
-    trainIdx.create(1, nQuery, CV_32S);
-    distance.create(1, nQuery, CV_32F);
+    ensureSizeIsEnough(1, nQuery, CV_32S, trainIdx);
+    ensureSizeIsEnough(1, nQuery, CV_32F, distance);
 
     match_caller_t func = match_callers[distType][queryDescs.depth()];
     CV_Assert(func != 0);
@@ -216,8 +220,18 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchSingle(const GpuMat& queryDescs,
     func(queryDescs, trainDescs, mask, trainIdx, trainIdx, distance, cc_12, StreamAccessor::getStream(stream));
 }
 
-void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& distance,
-    vector<DMatch>& matches)
+void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, vector<DMatch>& matches)
+{
+    if (trainIdx.empty() || distance.empty())
+        return;
+
+    Mat trainIdxCPU = trainIdx;
+    Mat distanceCPU = distance;
+
+    matchConvert(trainIdxCPU, distanceCPU, matches);
+}
+
+void cv::gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& distance, std::vector<DMatch>& matches)
 {
     if (trainIdx.empty() || distance.empty())
         return;
@@ -227,14 +241,11 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx,
 
     const int nQuery = trainIdx.cols;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat distanceCPU = distance;
-
     matches.clear();
     matches.reserve(nQuery);
 
-    const int* trainIdx_ptr = trainIdxCPU.ptr<int>();
-    const float* distance_ptr =  distanceCPU.ptr<float>();
+    const int* trainIdx_ptr = trainIdx.ptr<int>();
+    const float* distance_ptr =  distance.ptr<float>();
     for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx, ++trainIdx_ptr, ++distance_ptr)
     {
         int trainIdx = *trainIdx_ptr;
@@ -265,7 +276,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::makeGpuCollection(GpuMat& trainCollect
 
     if (masks.empty())
     {
-        Mat trainCollectionCPU(1, trainDescCollection.size(), CV_8UC(sizeof(DevMem2D)));
+        Mat trainCollectionCPU(1, static_cast<int>(trainDescCollection.size()), CV_8UC(sizeof(DevMem2D)));
 
         for (size_t i = 0; i < trainDescCollection.size(); ++i)
         {
@@ -280,8 +291,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::makeGpuCollection(GpuMat& trainCollect
     {
         CV_Assert(masks.size() == trainDescCollection.size());
 
-        Mat trainCollectionCPU(1, trainDescCollection.size(), CV_8UC(sizeof(DevMem2D)));
-        Mat maskCollectionCPU(1, trainDescCollection.size(), CV_8UC(sizeof(PtrStep)));
+        Mat trainCollectionCPU(1, static_cast<int>(trainDescCollection.size()), CV_8UC(sizeof(DevMem2D)));
+        Mat maskCollectionCPU(1, static_cast<int>(trainDescCollection.size()), CV_8UC(sizeof(PtrStep)));
 
         for (size_t i = 0; i < trainDescCollection.size(); ++i)
         {
@@ -335,9 +346,9 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchCollection(const GpuMat& queryDes
 
     const int nQuery = queryDescs.rows;
 
-    trainIdx.create(1, nQuery, CV_32S);
-    imgIdx.create(1, nQuery, CV_32S);
-    distance.create(1, nQuery, CV_32F);
+    ensureSizeIsEnough(1, nQuery, CV_32S, trainIdx);
+    ensureSizeIsEnough(1, nQuery, CV_32S, imgIdx);
+    ensureSizeIsEnough(1, nQuery, CV_32F, distance);
 
     match_caller_t func = match_callers[distType][queryDescs.depth()];
     CV_Assert(func != 0);
@@ -347,8 +358,19 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchCollection(const GpuMat& queryDes
     func(queryDescs, trainCollection, maskCollection, trainIdx, imgIdx, distance, cc_12, StreamAccessor::getStream(stream));
 }
 
-void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx,
-    const GpuMat& distance, vector<DMatch>& matches)
+void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, vector<DMatch>& matches)
+{
+    if (trainIdx.empty() || imgIdx.empty() || distance.empty())
+        return;
+
+    Mat trainIdxCPU = trainIdx;
+    Mat imgIdxCPU = imgIdx;
+    Mat distanceCPU = distance;
+
+    matchConvert(trainIdxCPU, imgIdxCPU, distanceCPU, matches);
+}
+
+void cv::gpu::BruteForceMatcher_GPU_base::matchConvert(const Mat& trainIdx, const Mat& imgIdx, const Mat& distance, std::vector<DMatch>& matches)
 {
     if (trainIdx.empty() || imgIdx.empty() || distance.empty())
         return;
@@ -359,16 +381,12 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx,
 
     const int nQuery = trainIdx.cols;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat imgIdxCPU = imgIdx;
-    Mat distanceCPU = distance;
-
     matches.clear();
     matches.reserve(nQuery);
 
-    const int* trainIdx_ptr = trainIdxCPU.ptr<int>();
-    const int* imgIdx_ptr = imgIdxCPU.ptr<int>();
-    const float* distance_ptr =  distanceCPU.ptr<float>();
+    const int* trainIdx_ptr = trainIdx.ptr<int>();
+    const int* imgIdx_ptr = imgIdx.ptr<int>();
+    const float* distance_ptr =  distance.ptr<float>();
     for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx, ++trainIdx_ptr, ++imgIdx_ptr, ++distance_ptr)
     {
         int trainIdx = *trainIdx_ptr;
@@ -385,8 +403,7 @@ void cv::gpu::BruteForceMatcher_GPU_base::matchDownload(const GpuMat& trainIdx,
     }
 }
 
-void cv::gpu::BruteForceMatcher_GPU_base::match(const GpuMat& queryDescs, vector<DMatch>& matches,
-    const vector<GpuMat>& masks)
+void cv::gpu::BruteForceMatcher_GPU_base::match(const GpuMat& queryDescs, vector<DMatch>& matches, const vector<GpuMat>& masks)
 {
     GpuMat trainCollection;
     GpuMat maskCollection;
@@ -435,8 +452,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatch(const GpuMat& queryDescs, con
     const int nQuery = queryDescs.rows;
     const int nTrain = trainDescs.rows;
 
-    trainIdx.create(nQuery, k, CV_32S);
-    distance.create(nQuery, k, CV_32F);
+    ensureSizeIsEnough(nQuery, k, CV_32S, trainIdx);
+    ensureSizeIsEnough(nQuery, k, CV_32F, distance);
     ensureSizeIsEnough(nQuery, nTrain, CV_32FC1, allDist);
 
     if (stream)
@@ -462,15 +479,24 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat& trainId
     if (trainIdx.empty() || distance.empty())
         return;
 
+    Mat trainIdxCPU = trainIdx;
+    Mat distanceCPU = distance;
+
+    knnMatchConvert(trainIdxCPU, distanceCPU, matches, compactResult);
+}
+
+void cv::gpu::BruteForceMatcher_GPU_base::knnMatchConvert(const Mat& trainIdx, const Mat& distance, 
+                                                          std::vector< std::vector<DMatch> >& matches, bool compactResult)
+{
+    if (trainIdx.empty() || distance.empty())
+        return;
+
     CV_Assert(trainIdx.type() == CV_32SC1);
     CV_Assert(distance.type() == CV_32FC1 && distance.size() == trainIdx.size());
 
     const int nQuery = distance.rows;
     const int k = trainIdx.cols;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat distanceCPU = distance;
-
     matches.clear();
     matches.reserve(nQuery);
 
@@ -480,8 +506,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::knnMatchDownload(const GpuMat& trainId
         vector<DMatch>& curMatches = matches.back();
         curMatches.reserve(k);
 
-        int* trainIdx_ptr = trainIdxCPU.ptr<int>(queryIdx);
-        float* distance_ptr = distanceCPU.ptr<float>(queryIdx);
+        const int* trainIdx_ptr = trainIdx.ptr<int>(queryIdx);
+        const float* distance_ptr = distance.ptr<float>(queryIdx);
         for (int i = 0; i < k; ++i, ++trainIdx_ptr, ++distance_ptr)
         {
             int trainIdx = *trainIdx_ptr;
@@ -593,8 +619,8 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatch(const GpuMat& queryDescs,
     ensureSizeIsEnough(1, nQuery, CV_32SC1, nMatches);
     if (trainIdx.empty())
     {
-        trainIdx.create(nQuery, nTrain, CV_32SC1);
-        distance.create(nQuery, nTrain, CV_32FC1);
+        ensureSizeIsEnough(nQuery, nTrain, CV_32SC1, trainIdx);
+        ensureSizeIsEnough(nQuery, nTrain, CV_32FC1, distance);
     }
 
     if (stream)
@@ -614,24 +640,33 @@ void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchDownload(const GpuMat& trai
     if (trainIdx.empty() || nMatches.empty() || distance.empty())
         return;
 
+    Mat trainIdxCPU = trainIdx;
+    Mat nMatchesCPU = nMatches;
+    Mat distanceCPU = distance;
+
+    radiusMatchConvert(trainIdxCPU, nMatchesCPU, distanceCPU, matches, compactResult);
+}
+
+void cv::gpu::BruteForceMatcher_GPU_base::radiusMatchConvert(const Mat& trainIdx, const Mat& nMatches, const Mat& distance,
+                std::vector< std::vector<DMatch> >& matches, bool compactResult)
+{
+    if (trainIdx.empty() || nMatches.empty() || distance.empty())
+        return;
+
     CV_Assert(trainIdx.type() == CV_32SC1);
     CV_Assert(nMatches.type() == CV_32SC1 && nMatches.isContinuous() && nMatches.cols >= trainIdx.rows);
     CV_Assert(distance.type() == CV_32FC1 && distance.size() == trainIdx.size());
 
     const int nQuery = trainIdx.rows;
 
-    Mat trainIdxCPU = trainIdx;
-    Mat nMatchesCPU = nMatches;
-    Mat distanceCPU = distance;
-
     matches.clear();
     matches.reserve(nQuery);
 
-    const unsigned int* nMatches_ptr = nMatchesCPU.ptr<unsigned int>();
+    const unsigned int* nMatches_ptr = nMatches.ptr<unsigned int>();
     for (int queryIdx = 0; queryIdx < nQuery; ++queryIdx)
     {
-        const int* trainIdx_ptr = trainIdxCPU.ptr<int>(queryIdx);
-        const float* distance_ptr = distanceCPU.ptr<float>(queryIdx);
+        const int* trainIdx_ptr = trainIdx.ptr<int>(queryIdx);
+        const float* distance_ptr = distance.ptr<float>(queryIdx);
 
         const int nMatches = std::min(static_cast<int>(nMatches_ptr[queryIdx]), trainIdx.cols);
 
diff --git a/modules/gpu/src/calib3d.cpp b/modules/gpu/src/calib3d.cpp
index 84db041148..301ea8167e 100644
--- a/modules/gpu/src/calib3d.cpp
+++ b/modules/gpu/src/calib3d.cpp
@@ -1,290 +1,290 @@
-/*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*/
-
-#include "precomp.hpp"
-
-#if !defined(HAVE_CUDA)
-
-void cv::gpu::transformPoints(const GpuMat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_nogpu(); }
-
-void cv::gpu::projectPoints(const GpuMat&, const Mat&, const Mat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_nogpu(); }
-
-void cv::gpu::solvePnPRansac(const Mat&, const Mat&, const Mat&, const Mat&, Mat&, Mat&, bool, int, float, int, vector<int>*) { throw_nogpu(); }
-
-#else
-
-using namespace cv;
-using namespace cv::gpu;
-
-namespace cv { namespace gpu { namespace transform_points 
-{
-    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, DevMem2D_<float3> dst, cudaStream_t stream);
-}}}
-
-namespace
-{
-    void transformPointsCaller(const GpuMat& src, const Mat& rvec, const Mat& tvec, GpuMat& dst, cudaStream_t stream)
-    {
-        CV_Assert(src.rows == 1 && src.cols > 0 && src.type() == CV_32FC3);
-        CV_Assert(rvec.size() == Size(3, 1) && rvec.type() == CV_32F);
-        CV_Assert(tvec.size() == Size(3, 1) && tvec.type() == CV_32F);
-
-        // Convert rotation vector into matrix
-        Mat rot;
-        Rodrigues(rvec, rot);
-
-        dst.create(src.size(), src.type());
-        transform_points::call(src, rot.ptr<float>(), tvec.ptr<float>(), dst, stream);
-    }
-}
-
-void cv::gpu::transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, GpuMat& dst, Stream& stream)
-{
-    ::transformPointsCaller(src, rvec, tvec, dst, StreamAccessor::getStream(stream));
-}
-
-namespace cv { namespace gpu { namespace project_points 
-{
-    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
-}}}
-
-
-namespace
-{
-    void projectPointsCaller(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, cudaStream_t stream)
-    {
-        CV_Assert(src.rows == 1 && src.cols > 0 && src.type() == CV_32FC3);
-        CV_Assert(rvec.size() == Size(3, 1) && rvec.type() == CV_32F);
-        CV_Assert(tvec.size() == Size(3, 1) && tvec.type() == CV_32F);
-        CV_Assert(camera_mat.size() == Size(3, 3) && camera_mat.type() == CV_32F);
-        CV_Assert(dist_coef.empty()); // Undistortion isn't supported
-
-        // Convert rotation vector into matrix
-        Mat rot;
-        Rodrigues(rvec, rot);
-
-        dst.create(src.size(), CV_32FC2);
-        project_points::call(src, rot.ptr<float>(), tvec.ptr<float>(), camera_mat.ptr<float>(), dst,stream);
-    }
-}
-
-void cv::gpu::projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, Stream& stream)
-{
-    ::projectPointsCaller(src, rvec, tvec, camera_mat, dist_coef, dst, StreamAccessor::getStream(stream));
-}
-
-
-namespace cv { namespace gpu { namespace solve_pnp_ransac
-{
-    int maxNumIters();
-
-    void computeHypothesisScores(
-            const int num_hypotheses, const int num_points, const float* rot_matrices,
-            const float3* transl_vectors, const float3* object, const float2* image,
-            const float dist_threshold, int* hypothesis_scores);
-}}}
-
-namespace
-{
-    // Selects subset_size random different points from [0, num_points - 1] range
-    void selectRandom(int subset_size, int num_points, vector<int>& subset)
-    {
-        subset.resize(subset_size);
-        for (int i = 0; i < subset_size; ++i)
-        {
-            bool was;
-            do
-            {
-                subset[i] = rand() % num_points;
-                was = false;
-                for (int j = 0; j < i; ++j)
-                    if (subset[j] == subset[i])
-                    {
-                        was = true;
-                        break;
-                    }
-            } while (was);
-        }
-    }
-
-    // Computes rotation, translation pair for small subsets if the input data
-    class TransformHypothesesGenerator
-    {
-    public:
-        TransformHypothesesGenerator(const Mat& object_, const Mat& image_, const Mat& dist_coef_, 
-                                     const Mat& camera_mat_, int num_points_, int subset_size_, 
-                                     Mat rot_matrices_, Mat transl_vectors_)
-                : object(&object_), image(&image_), dist_coef(&dist_coef_), camera_mat(&camera_mat_), 
-                  num_points(num_points_), subset_size(subset_size_), rot_matrices(rot_matrices_), 
-                  transl_vectors(transl_vectors_) {}
-
-        void operator()(const BlockedRange& range) const
-        {
-            // Input data for generation of the current hypothesis
-            vector<int> subset_indices(subset_size);
-            Mat_<Point3f> object_subset(1, subset_size);
-            Mat_<Point2f> image_subset(1, subset_size);
-
-            // Current hypothesis data
-            Mat rot_vec(1, 3, CV_64F);
-            Mat rot_mat(3, 3, CV_64F);
-            Mat transl_vec(1, 3, CV_64F);
-
-            for (int iter = range.begin(); iter < range.end(); ++iter)
-            {
-                selectRandom(subset_size, num_points, subset_indices);
-                for (int i = 0; i < subset_size; ++i)
-                {
-                   object_subset(0, i) = object->at<Point3f>(subset_indices[i]);
-                   image_subset(0, i) = image->at<Point2f>(subset_indices[i]);
-                }
-
-                solvePnP(object_subset, image_subset, *camera_mat, *dist_coef, rot_vec, transl_vec);
-
-                // Remember translation vector
-                Mat transl_vec_ = transl_vectors.colRange(iter * 3, (iter + 1) * 3);
-                transl_vec = transl_vec.reshape(0, 1);
-                transl_vec.convertTo(transl_vec_, CV_32F);
-
-                // Remember rotation matrix
-                Rodrigues(rot_vec, rot_mat);
-                Mat rot_mat_ = rot_matrices.colRange(iter * 9, (iter + 1) * 9).reshape(0, 3);
-                rot_mat.convertTo(rot_mat_, CV_32F);
-            }
-        }
-
-        const Mat* object;
-        const Mat* image;
-        const Mat* dist_coef;
-        const Mat* camera_mat;
-        int num_points;
-        int subset_size;
-
-        // Hypotheses storage (global)
-        Mat rot_matrices;
-        Mat transl_vectors;
-    };
-}
-
+/*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*/
+
+#include "precomp.hpp"
+
+#if !defined(HAVE_CUDA)
+
+void cv::gpu::transformPoints(const GpuMat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_nogpu(); }
+
+void cv::gpu::projectPoints(const GpuMat&, const Mat&, const Mat&, const Mat&, const Mat&, GpuMat&, Stream&) { throw_nogpu(); }
+
+void cv::gpu::solvePnPRansac(const Mat&, const Mat&, const Mat&, const Mat&, Mat&, Mat&, bool, int, float, int, vector<int>*) { throw_nogpu(); }
+
+#else
+
+using namespace cv;
+using namespace cv::gpu;
+
+namespace cv { namespace gpu { namespace transform_points 
+{
+    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, DevMem2D_<float3> dst, cudaStream_t stream);
+}}}
+
+namespace
+{
+    void transformPointsCaller(const GpuMat& src, const Mat& rvec, const Mat& tvec, GpuMat& dst, cudaStream_t stream)
+    {
+        CV_Assert(src.rows == 1 && src.cols > 0 && src.type() == CV_32FC3);
+        CV_Assert(rvec.size() == Size(3, 1) && rvec.type() == CV_32F);
+        CV_Assert(tvec.size() == Size(3, 1) && tvec.type() == CV_32F);
+
+        // Convert rotation vector into matrix
+        Mat rot;
+        Rodrigues(rvec, rot);
+
+        dst.create(src.size(), src.type());
+        transform_points::call(src, rot.ptr<float>(), tvec.ptr<float>(), dst, stream);
+    }
+}
+
+void cv::gpu::transformPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, GpuMat& dst, Stream& stream)
+{
+    ::transformPointsCaller(src, rvec, tvec, dst, StreamAccessor::getStream(stream));
+}
+
+namespace cv { namespace gpu { namespace project_points 
+{
+    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
+}}}
+
+
+namespace
+{
+    void projectPointsCaller(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, cudaStream_t stream)
+    {
+        CV_Assert(src.rows == 1 && src.cols > 0 && src.type() == CV_32FC3);
+        CV_Assert(rvec.size() == Size(3, 1) && rvec.type() == CV_32F);
+        CV_Assert(tvec.size() == Size(3, 1) && tvec.type() == CV_32F);
+        CV_Assert(camera_mat.size() == Size(3, 3) && camera_mat.type() == CV_32F);
+        CV_Assert(dist_coef.empty()); // Undistortion isn't supported
+
+        // Convert rotation vector into matrix
+        Mat rot;
+        Rodrigues(rvec, rot);
+
+        dst.create(src.size(), CV_32FC2);
+        project_points::call(src, rot.ptr<float>(), tvec.ptr<float>(), camera_mat.ptr<float>(), dst,stream);
+    }
+}
+
+void cv::gpu::projectPoints(const GpuMat& src, const Mat& rvec, const Mat& tvec, const Mat& camera_mat, const Mat& dist_coef, GpuMat& dst, Stream& stream)
+{
+    ::projectPointsCaller(src, rvec, tvec, camera_mat, dist_coef, dst, StreamAccessor::getStream(stream));
+}
+
+
+namespace cv { namespace gpu { namespace solve_pnp_ransac
+{
+    int maxNumIters();
+
+    void computeHypothesisScores(
+            const int num_hypotheses, const int num_points, const float* rot_matrices,
+            const float3* transl_vectors, const float3* object, const float2* image,
+            const float dist_threshold, int* hypothesis_scores);
+}}}
+
+namespace
+{
+    // Selects subset_size random different points from [0, num_points - 1] range
+    void selectRandom(int subset_size, int num_points, vector<int>& subset)
+    {
+        subset.resize(subset_size);
+        for (int i = 0; i < subset_size; ++i)
+        {
+            bool was;
+            do
+            {
+                subset[i] = rand() % num_points;
+                was = false;
+                for (int j = 0; j < i; ++j)
+                    if (subset[j] == subset[i])
+                    {
+                        was = true;
+                        break;
+                    }
+            } while (was);
+        }
+    }
+
+    // Computes rotation, translation pair for small subsets if the input data
+    class TransformHypothesesGenerator
+    {
+    public:
+        TransformHypothesesGenerator(const Mat& object_, const Mat& image_, const Mat& dist_coef_, 
+                                     const Mat& camera_mat_, int num_points_, int subset_size_, 
+                                     Mat rot_matrices_, Mat transl_vectors_)
+                : object(&object_), image(&image_), dist_coef(&dist_coef_), camera_mat(&camera_mat_), 
+                  num_points(num_points_), subset_size(subset_size_), rot_matrices(rot_matrices_), 
+                  transl_vectors(transl_vectors_) {}
+
+        void operator()(const BlockedRange& range) const
+        {
+            // Input data for generation of the current hypothesis
+            vector<int> subset_indices(subset_size);
+            Mat_<Point3f> object_subset(1, subset_size);
+            Mat_<Point2f> image_subset(1, subset_size);
+
+            // Current hypothesis data
+            Mat rot_vec(1, 3, CV_64F);
+            Mat rot_mat(3, 3, CV_64F);
+            Mat transl_vec(1, 3, CV_64F);
+
+            for (int iter = range.begin(); iter < range.end(); ++iter)
+            {
+                selectRandom(subset_size, num_points, subset_indices);
+                for (int i = 0; i < subset_size; ++i)
+                {
+                   object_subset(0, i) = object->at<Point3f>(subset_indices[i]);
+                   image_subset(0, i) = image->at<Point2f>(subset_indices[i]);
+                }
+
+                solvePnP(object_subset, image_subset, *camera_mat, *dist_coef, rot_vec, transl_vec);
+
+                // Remember translation vector
+                Mat transl_vec_ = transl_vectors.colRange(iter * 3, (iter + 1) * 3);
+                transl_vec = transl_vec.reshape(0, 1);
+                transl_vec.convertTo(transl_vec_, CV_32F);
+
+                // Remember rotation matrix
+                Rodrigues(rot_vec, rot_mat);
+                Mat rot_mat_ = rot_matrices.colRange(iter * 9, (iter + 1) * 9).reshape(0, 3);
+                rot_mat.convertTo(rot_mat_, CV_32F);
+            }
+        }
+
+        const Mat* object;
+        const Mat* image;
+        const Mat* dist_coef;
+        const Mat* camera_mat;
+        int num_points;
+        int subset_size;
+
+        // Hypotheses storage (global)
+        Mat rot_matrices;
+        Mat transl_vectors;
+    };
+}
+
 void cv::gpu::solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat,
                              const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess,
                              int num_iters, float max_dist, int min_inlier_count, 
-                             vector<int>* inliers)
-{
-    CV_Assert(object.rows == 1 && object.cols > 0 && object.type() == CV_32FC3);
-    CV_Assert(image.rows == 1 && image.cols > 0 && image.type() == CV_32FC2);
-    CV_Assert(object.cols == image.cols);
-    CV_Assert(camera_mat.size() == Size(3, 3) && camera_mat.type() == CV_32F);
-    CV_Assert(!use_extrinsic_guess); // We don't support initial guess for now
-    CV_Assert(num_iters <= solve_pnp_ransac::maxNumIters());
-
-    const int subset_size = 4;
-    const int num_points = object.cols;
-    CV_Assert(num_points >= subset_size);
-
-    // Unapply distortion and intrinsic camera transformations
-    Mat eye_camera_mat = Mat::eye(3, 3, CV_32F);
-    Mat empty_dist_coef;
-    Mat image_normalized;
-    undistortPoints(image, image_normalized, camera_mat, dist_coef, Mat(), eye_camera_mat);
-
-    // Hypotheses storage (global)
-    Mat rot_matrices(1, num_iters * 9, CV_32F);
-    Mat transl_vectors(1, num_iters * 3, CV_32F);
-
-    // Generate set of hypotheses using small subsets of the input data
-    TransformHypothesesGenerator body(object, image_normalized, empty_dist_coef, eye_camera_mat, 
-                                      num_points, subset_size, rot_matrices, transl_vectors);
-    parallel_for(BlockedRange(0, num_iters), body);
-
-    // Compute scores (i.e. number of inliers) for each hypothesis
-    GpuMat d_object(object);
-    GpuMat d_image_normalized(image_normalized);
-    GpuMat d_hypothesis_scores(1, num_iters, CV_32S);
-    solve_pnp_ransac::computeHypothesisScores(
-            num_iters, num_points, rot_matrices.ptr<float>(), transl_vectors.ptr<float3>(),
-            d_object.ptr<float3>(), d_image_normalized.ptr<float2>(), max_dist * max_dist, 
-            d_hypothesis_scores.ptr<int>());
-
-    // Find the best hypothesis index
-    Point best_idx;
-    double best_score;
-    minMaxLoc(d_hypothesis_scores, NULL, &best_score, NULL, &best_idx);
-    int num_inliers = static_cast<int>(best_score);
-
-    // Extract the best hypothesis data
-
-    Mat rot_mat = rot_matrices.colRange(best_idx.x * 9, (best_idx.x + 1) * 9).reshape(0, 3);
-    Rodrigues(rot_mat, rvec);
-    rvec = rvec.reshape(0, 1);
-
-    tvec = transl_vectors.colRange(best_idx.x * 3, (best_idx.x + 1) * 3).clone();
-    tvec = tvec.reshape(0, 1);
-
-    // Build vector of inlier indices
-    if (inliers != NULL)
-    {
-        inliers->clear();
-        inliers->reserve(num_inliers);
-
-        Point3f p, p_transf;
-        Point2f p_proj;
-        const float* rot = rot_mat.ptr<float>();
-        const float* transl = tvec.ptr<float>();
-
-        for (int i = 0; i < num_points; ++i)
-        {
-            p = object.at<Point3f>(0, i);
-            p_transf.x = rot[0] * p.x + rot[1] * p.y + rot[2] * p.z + transl[0];
-            p_transf.y = rot[3] * p.x + rot[4] * p.y + rot[5] * p.z + transl[1];
-            p_transf.z = rot[6] * p.x + rot[7] * p.y + rot[8] * p.z + transl[2];
-            p_proj.x = p_transf.x / p_transf.z;
-            p_proj.y = p_transf.y / p_transf.z;
-            if (norm(p_proj - image_normalized.at<Point2f>(0, i)) < max_dist)
-                inliers->push_back(i);
-        }
-    }
-}
-
-#endif
-
-
+                             vector<int>* inliers)
+{
+    CV_Assert(object.rows == 1 && object.cols > 0 && object.type() == CV_32FC3);
+    CV_Assert(image.rows == 1 && image.cols > 0 && image.type() == CV_32FC2);
+    CV_Assert(object.cols == image.cols);
+    CV_Assert(camera_mat.size() == Size(3, 3) && camera_mat.type() == CV_32F);
+    CV_Assert(!use_extrinsic_guess); // We don't support initial guess for now
+    CV_Assert(num_iters <= solve_pnp_ransac::maxNumIters());
+
+    const int subset_size = 4;
+    const int num_points = object.cols;
+    CV_Assert(num_points >= subset_size);
+
+    // Unapply distortion and intrinsic camera transformations
+    Mat eye_camera_mat = Mat::eye(3, 3, CV_32F);
+    Mat empty_dist_coef;
+    Mat image_normalized;
+    undistortPoints(image, image_normalized, camera_mat, dist_coef, Mat(), eye_camera_mat);
+
+    // Hypotheses storage (global)
+    Mat rot_matrices(1, num_iters * 9, CV_32F);
+    Mat transl_vectors(1, num_iters * 3, CV_32F);
+
+    // Generate set of hypotheses using small subsets of the input data
+    TransformHypothesesGenerator body(object, image_normalized, empty_dist_coef, eye_camera_mat, 
+                                      num_points, subset_size, rot_matrices, transl_vectors);
+    parallel_for(BlockedRange(0, num_iters), body);
+
+    // Compute scores (i.e. number of inliers) for each hypothesis
+    GpuMat d_object(object);
+    GpuMat d_image_normalized(image_normalized);
+    GpuMat d_hypothesis_scores(1, num_iters, CV_32S);
+    solve_pnp_ransac::computeHypothesisScores(
+            num_iters, num_points, rot_matrices.ptr<float>(), transl_vectors.ptr<float3>(),
+            d_object.ptr<float3>(), d_image_normalized.ptr<float2>(), max_dist * max_dist, 
+            d_hypothesis_scores.ptr<int>());
+
+    // Find the best hypothesis index
+    Point best_idx;
+    double best_score;
+    minMaxLoc(d_hypothesis_scores, NULL, &best_score, NULL, &best_idx);
+    int num_inliers = static_cast<int>(best_score);
+
+    // Extract the best hypothesis data
+
+    Mat rot_mat = rot_matrices.colRange(best_idx.x * 9, (best_idx.x + 1) * 9).reshape(0, 3);
+    Rodrigues(rot_mat, rvec);
+    rvec = rvec.reshape(0, 1);
+
+    tvec = transl_vectors.colRange(best_idx.x * 3, (best_idx.x + 1) * 3).clone();
+    tvec = tvec.reshape(0, 1);
+
+    // Build vector of inlier indices
+    if (inliers != NULL)
+    {
+        inliers->clear();
+        inliers->reserve(num_inliers);
+
+        Point3f p, p_transf;
+        Point2f p_proj;
+        const float* rot = rot_mat.ptr<float>();
+        const float* transl = tvec.ptr<float>();
+
+        for (int i = 0; i < num_points; ++i)
+        {
+            p = object.at<Point3f>(0, i);
+            p_transf.x = rot[0] * p.x + rot[1] * p.y + rot[2] * p.z + transl[0];
+            p_transf.y = rot[3] * p.x + rot[4] * p.y + rot[5] * p.z + transl[1];
+            p_transf.z = rot[6] * p.x + rot[7] * p.y + rot[8] * p.z + transl[2];
+            p_proj.x = p_transf.x / p_transf.z;
+            p_proj.y = p_transf.y / p_transf.z;
+            if (norm(p_proj - image_normalized.at<Point2f>(0, i)) < max_dist)
+                inliers->push_back(i);
+        }
+    }
+}
+
+#endif
+
+
diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp
index 0ffd10c715..984b33f820 100644
--- a/modules/gpu/src/cascadeclassifier.cpp
+++ b/modules/gpu/src/cascadeclassifier.cpp
@@ -87,7 +87,7 @@ struct cv::gpu::CascadeClassifier_GPU::CascadeClassifierImpl
         src_seg.begin = src_beg;
         src_seg.size  = src.step * src.rows;
 
-        NCVMatrixReuse<Ncv8u> d_src(src_seg, devProp.textureAlignment, src.cols, src.rows, src.step, true);
+        NCVMatrixReuse<Ncv8u> d_src(src_seg, static_cast<int>(devProp.textureAlignment), src.cols, src.rows, static_cast<int>(src.step), true);
         ncvAssertReturn(d_src.isMemReused(), NCV_ALLOCATOR_BAD_REUSE);
 
         CV_Assert(objects.rows == 1);
@@ -141,8 +141,8 @@ private:
         ncvAssertCUDAReturn(cudaGetDeviceProperties(&devProp, devId), NCV_CUDA_ERROR);
 
         // Load the classifier from file (assuming its size is about 1 mb) using a simple allocator
-        gpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeDevice, devProp.textureAlignment);
-        cpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, devProp.textureAlignment);
+        gpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeDevice, static_cast<int>(devProp.textureAlignment));
+        cpuCascadeAllocator = new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, static_cast<int>(devProp.textureAlignment));
 
         ncvAssertPrintReturn(gpuCascadeAllocator->isInitialized(), "Error creating cascade GPU allocator", NCV_CUDA_ERROR);
         ncvAssertPrintReturn(cpuCascadeAllocator->isInitialized(), "Error creating cascade CPU allocator", NCV_CUDA_ERROR);
@@ -189,8 +189,8 @@ private:
         }
 
         // Calculate memory requirements and create real allocators
-        NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
-        NCVMemStackAllocator cpuCounter(devProp.textureAlignment);
+        NCVMemStackAllocator gpuCounter(static_cast<int>(devProp.textureAlignment));
+        NCVMemStackAllocator cpuCounter(static_cast<int>(devProp.textureAlignment));
 
         ncvAssertPrintReturn(gpuCounter.isInitialized(), "Error creating GPU memory counter", NCV_CUDA_ERROR);
         ncvAssertPrintReturn(cpuCounter.isInitialized(), "Error creating CPU memory counter", NCV_CUDA_ERROR);
@@ -214,8 +214,8 @@ private:
         ncvAssertReturnNcvStat(ncvStat);
         ncvAssertCUDAReturn(cudaStreamSynchronize(0), NCV_CUDA_ERROR);
 
-        gpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), devProp.textureAlignment);
-        cpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), devProp.textureAlignment);
+        gpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), static_cast<int>(devProp.textureAlignment));
+        cpuAllocator = new NCVMemStackAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), static_cast<int>(devProp.textureAlignment));
 
         ncvAssertPrintReturn(gpuAllocator->isInitialized(), "Error creating GPU memory allocator", NCV_CUDA_ERROR);
         ncvAssertPrintReturn(cpuAllocator->isInitialized(), "Error creating CPU memory allocator", NCV_CUDA_ERROR);
@@ -372,7 +372,7 @@ NCVStatus loadFromXML(const std::string &filename,
     for(int s = 0; s < stagesCound; ++s) // by stages
     {
         HaarStage64 curStage;
-        curStage.setStartClassifierRootNodeOffset(haarClassifierNodes.size());
+        curStage.setStartClassifierRootNodeOffset(static_cast<Ncv32u>(haarClassifierNodes.size()));
 
         curStage.setStageThreshold(oldCascade->stage_classifier[s].threshold);
 
@@ -452,7 +452,7 @@ NCVStatus loadFromXML(const std::string &filename,
 
                 HaarFeatureDescriptor32 tmpFeatureDesc;
                 ncvStat = tmpFeatureDesc.create(haar.bNeedsTiltedII, bIsLeftNodeLeaf, bIsRightNodeLeaf,
-                    featureId, haarFeatures.size() - featureId);
+                    featureId, static_cast<Ncv32u>(haarFeatures.size()) - featureId);
                 ncvAssertReturn(NCV_SUCCESS == ncvStat, ncvStat);
                 curNode.setFeatureDesc(tmpFeatureDesc);
 
@@ -478,13 +478,13 @@ NCVStatus loadFromXML(const std::string &filename,
     }
 
     //fill in cascade stats
-    haar.NumStages = haarStages.size();
-    haar.NumClassifierRootNodes = haarClassifierNodes.size();
-    haar.NumClassifierTotalNodes = haar.NumClassifierRootNodes + h_TmpClassifierNotRootNodes.size();
-    haar.NumFeatures = haarFeatures.size();
+    haar.NumStages = static_cast<Ncv32u>(haarStages.size());
+    haar.NumClassifierRootNodes = static_cast<Ncv32u>(haarClassifierNodes.size());
+    haar.NumClassifierTotalNodes = static_cast<Ncv32u>(haar.NumClassifierRootNodes + h_TmpClassifierNotRootNodes.size());
+    haar.NumFeatures = static_cast<Ncv32u>(haarFeatures.size());
 
     //merge root and leaf nodes in one classifiers array
-    Ncv32u offsetRoot = haarClassifierNodes.size();
+    Ncv32u offsetRoot = static_cast<Ncv32u>(haarClassifierNodes.size());
     for (Ncv32u i=0; i<haarClassifierNodes.size(); i++)
     {
         HaarFeatureDescriptor32 featureDesc = haarClassifierNodes[i].getFeatureDesc();
diff --git a/modules/gpu/src/color.cpp b/modules/gpu/src/color.cpp
index 4d9bd50167..c539f3a6da 100644
--- a/modules/gpu/src/color.cpp
+++ b/modules/gpu/src/color.cpp
@@ -53,410 +53,1376 @@ void cv::gpu::cvtColor(const GpuMat&, GpuMat&, int, int, Stream&) { throw_nogpu(
 
 namespace cv { namespace gpu {  namespace color  
 {
-    void RGB2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream);
-    void RGB2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream);
-    void RGB2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream);
+    #define OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name) \
+        void name(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
 
-    void RGB5x52RGB_gpu(const DevMem2D& src, int green_bits, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream);
-    void RGB2RGB5x5_gpu(const DevMem2D& src, int srccn, const DevMem2D& dst, int green_bits, int bidx, cudaStream_t stream);
+    #define OPENCV_GPU_DECLARE_CVTCOLOR_ALL(name) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _16u) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f)
 
-    void Gray2RGB_gpu_8u(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream);
-    void Gray2RGB_gpu_16u(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream);
-    void Gray2RGB_gpu_32f(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream);
-    void Gray2RGB5x5_gpu(const DevMem2D& src, const DevMem2D& dst, int green_bits, cudaStream_t stream);
+    #define OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(name) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _8u) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _32f) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_8u) \
+        OPENCV_GPU_DECLARE_CVTCOLOR_ONE(name ## _full_32f)
 
-    void RGB2Gray_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream);
-    void RGB2Gray_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream);
-    void RGB2Gray_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream);
-    void RGB5x52Gray_gpu(const DevMem2D& src, int green_bits, const DevMem2D& dst, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_rgba)
 
-    void RGB2YCrCb_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
-    void RGB2YCrCb_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
-    void RGB2YCrCb_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr555)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr_to_bgr565)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr555)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgb_to_bgr565)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr555)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgra_to_bgr565)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr555)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(rgba_to_bgr565)
 
-    void YCrCb2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
-    void YCrCb2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
-    void YCrCb2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_bgra)
 
-    void RGB2XYZ_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
-    void RGB2XYZ_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
-    void RGB2XYZ_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(gray_to_bgra)
 
-    void XYZ2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
-    void XYZ2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
-    void XYZ2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr555)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(gray_to_bgr565)
 
-    void RGB2HSV_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
-    void RGB2HSV_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr555_to_gray)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ONE(bgr565_to_gray)
 
-    void HSV2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
-    void HSV2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_gray)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_gray)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_gray)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_gray)
 
-    void RGB2HLS_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
-    void RGB2HLS_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_yuv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_yuv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_yuv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_yuv4)
 
-    void HLS2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
-    void HLS2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream);
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(yuv4_to_bgra)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_YCrCb4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_YCrCb4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_YCrCb4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_YCrCb4)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(YCrCb4_to_bgra)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgb_to_xyz4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(rgba_to_xyz4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgr_to_xyz4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(bgra_to_xyz4)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_ALL(xyz4_to_bgra)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hsv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hsv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hsv4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hsv4)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hsv4_to_bgra)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgb_to_hls4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(rgba_to_hls4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgr_to_hls4)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(bgra_to_hls4)
+
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgb)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_rgba)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls_to_bgra)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgr)
+    OPENCV_GPU_DECLARE_CVTCOLOR_8U32F(hls4_to_bgra)
+
+    #undef OPENCV_GPU_DECLARE_CVTCOLOR_ONE
+    #undef OPENCV_GPU_DECLARE_CVTCOLOR_ALL
+    #undef OPENCV_GPU_DECLARE_CVTCOLOR_8U32F
 }}}
 
 namespace
 {
-    #undef R2Y
-    #undef G2Y
-    #undef B2Y
-    
-    enum
-    {
-        yuv_shift  = 14,
-        xyz_shift  = 12,
-        R2Y        = 4899,
-        G2Y        = 9617,
-        B2Y        = 1868,
-        BLOCK_SIZE = 256
-    };
-}
+    typedef void (*gpu_func_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
 
-namespace
-{
-    void cvtColor_caller(const GpuMat& src, GpuMat& dst, int code, int dcn, const cudaStream_t& stream) 
+    void bgr_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
     {
-        Size sz = src.size();
-        int scn = src.channels(), depth = src.depth(), bidx;
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgr_to_rgb_8u, 0, bgr_to_rgb_16u, 0, 0, bgr_to_rgb_32f};
         
-        CV_Assert(depth == CV_8U || depth == CV_16U || depth == CV_32F);
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3);
 
-        switch (code)
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 3));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgr_to_bgra_8u, 0, bgr_to_bgra_16u, 0, 0, bgr_to_bgra_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 4));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgr_to_rgba_8u, 0, bgr_to_rgba_16u, 0, 0, bgr_to_rgba_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 4));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgra_to_bgr_8u, 0, bgra_to_bgr_16u, 0, 0, bgra_to_bgr_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 3));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgra_to_rgb_8u, 0, bgra_to_rgb_16u, 0, 0, bgra_to_rgb_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 3));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgra_to_rgba_8u, 0, bgra_to_rgba_16u, 0, 0, bgra_to_rgba_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 4));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::bgr_to_bgr555(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::bgr_to_bgr565(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgb_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::rgb_to_bgr555(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgb_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::rgb_to_bgr565(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::bgra_to_bgr555(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::bgra_to_bgr565(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgba_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::rgba_to_bgr555(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgba_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::rgba_to_bgr565(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr555_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC3);        
+
+        color::bgr555_to_rgb(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr565_to_rgb(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC3);        
+
+        color::bgr565_to_rgb(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr555_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC3);        
+
+        color::bgr555_to_bgr(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr565_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC3);        
+
+        color::bgr565_to_bgr(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr555_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC4);        
+
+        color::bgr555_to_rgba(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr565_to_rgba(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC4);        
+
+        color::bgr565_to_rgba(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr555_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC4);        
+
+        color::bgr555_to_bgra(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr565_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC4);        
+
+        color::bgr565_to_bgra(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void gray_to_bgr(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {gray_to_bgr_8u, 0, gray_to_bgr_16u, 0, 0, gray_to_bgr_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 1);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 3));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void gray_to_bgra(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {gray_to_bgra_8u, 0, gray_to_bgra_16u, 0, 0, gray_to_bgra_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 1);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 4));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void gray_to_bgr555(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 1);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::gray_to_bgr555(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void gray_to_bgr565(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 1);
+
+        dst.create(src.size(), CV_8UC2);        
+
+        color::gray_to_bgr565(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr555_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC1);        
+
+        color::bgr555_to_gray(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr565_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {        
+        CV_Assert(src.depth() == CV_8U);
+        CV_Assert(src.channels() == 2);
+
+        dst.create(src.size(), CV_8UC1);        
+
+        color::bgr565_to_gray(src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgb_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {rgb_to_gray_8u, 0, rgb_to_gray_16u, 0, 0, rgb_to_gray_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 1));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgr_to_gray_8u, 0, bgr_to_gray_16u, 0, 0, bgr_to_gray_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 1));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void rgba_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {rgba_to_gray_8u, 0, rgba_to_gray_16u, 0, 0, rgba_to_gray_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 1));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgra_to_gray(const GpuMat& src, GpuMat& dst, int, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[] = {bgra_to_gray_8u, 0, bgra_to_gray_16u, 0, 0, bgra_to_gray_32f};
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), 1));        
+
+        funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+    
+    void rgb_to_yuv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
         {
-            case CV_BGR2BGRA: case CV_RGB2BGRA: case CV_BGRA2BGR:
-            case CV_RGBA2BGR: case CV_RGB2BGR: case CV_BGRA2RGBA:                
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream);
-                    static const func_t funcs[] = {color::RGB2RGB_gpu_8u, 0, color::RGB2RGB_gpu_16u, 0, 0, color::RGB2RGB_gpu_32f};
+            {
+                {rgb_to_yuv_8u, 0, rgb_to_yuv_16u, 0, 0, rgb_to_yuv_32f},
+                {rgba_to_yuv_8u, 0, rgba_to_yuv_16u, 0, 0, rgba_to_yuv_32f}
+            },
+            {
+                {rgb_to_yuv4_8u, 0, rgb_to_yuv4_16u, 0, 0, rgb_to_yuv4_32f},
+                {rgba_to_yuv4_8u, 0, rgba_to_yuv4_16u, 0, 0, rgba_to_yuv4_32f}
+            }
+        };
 
-                    CV_Assert(scn == 3 || scn == 4);
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    dcn = code == CV_BGR2BGRA || code == CV_RGB2BGRA || code == CV_BGRA2RGBA ? 4 : 3;
-                    bidx = code == CV_BGR2BGRA || code == CV_BGRA2BGR ? 0 : 2;
-                    
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    funcs[depth](src, scn, dst, dcn, bidx, stream);
-                    break;
-                }
-                
-            case CV_BGR2BGR565: case CV_BGR2BGR555: case CV_RGB2BGR565: case CV_RGB2BGR555:
-            case CV_BGRA2BGR565: case CV_BGRA2BGR555: case CV_RGBA2BGR565: case CV_RGBA2BGR555:
-                {
-                    CV_Assert((scn == 3 || scn == 4) && depth == CV_8U);
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    int green_bits = code == CV_BGR2BGR565 || code == CV_RGB2BGR565 
-                        || code == CV_BGRA2BGR565 || code == CV_RGBA2BGR565 ? 6 : 5;
-                    bidx = code == CV_BGR2BGR565 || code == CV_BGR2BGR555 
-                        || code == CV_BGRA2BGR565 || code == CV_BGRA2BGR555 ? 0 : 2;
+    void bgr_to_yuv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_yuv_8u, 0, bgr_to_yuv_16u, 0, 0, bgr_to_yuv_32f},
+                {bgra_to_yuv_8u, 0, bgra_to_yuv_16u, 0, 0, bgra_to_yuv_32f}
+            },
+            {
+                {bgr_to_yuv4_8u, 0, bgr_to_yuv4_16u, 0, 0, bgr_to_yuv4_32f},
+                {bgra_to_yuv4_8u, 0, bgra_to_yuv4_16u, 0, 0, bgra_to_yuv4_32f}
+            }
+        };
 
-                    dst.create(sz, CV_8UC2);
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    color::RGB2RGB5x5_gpu(src, scn, dst, green_bits, bidx, stream);
-                    break;
-                }
-            
-            case CV_BGR5652BGR: case CV_BGR5552BGR: case CV_BGR5652RGB: case CV_BGR5552RGB:
-            case CV_BGR5652BGRA: case CV_BGR5552BGRA: case CV_BGR5652RGBA: case CV_BGR5552RGBA:
-                {
-                    if (dcn <= 0) dcn = 3;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    CV_Assert((dcn == 3 || dcn == 4) && scn == 2 && depth == CV_8U);
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    int green_bits = code == CV_BGR5652BGR || code == CV_BGR5652RGB 
-                        || code == CV_BGR5652BGRA || code == CV_BGR5652RGBA ? 6 : 5;
-                    bidx = code == CV_BGR5652BGR || code == CV_BGR5552BGR 
-                        || code == CV_BGR5652BGRA || code == CV_BGR5552BGRA ? 0 : 2;
+    void yuv_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {yuv_to_rgb_8u, 0, yuv_to_rgb_16u, 0, 0, yuv_to_rgb_32f},
+                {yuv4_to_rgb_8u, 0, yuv4_to_rgb_16u, 0, 0, yuv4_to_rgb_32f}
+            },
+            {
+                {yuv_to_rgba_8u, 0, yuv_to_rgba_16u, 0, 0, yuv_to_rgba_32f},
+                {yuv4_to_rgba_8u, 0, yuv4_to_rgba_16u, 0, 0, yuv4_to_rgba_32f}
+            }
+        };
 
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    color::RGB5x52RGB_gpu(src, green_bits, dst, dcn, bidx, stream);
-                    break;
-                }
-                        
-            case CV_BGR2GRAY: case CV_BGRA2GRAY: case CV_RGB2GRAY: case CV_RGBA2GRAY:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream);
-                    static const func_t funcs[] = {color::RGB2Gray_gpu_8u, 0, color::RGB2Gray_gpu_16u, 0, 0, color::RGB2Gray_gpu_32f};
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    CV_Assert(scn == 3 || scn == 4);
-                    
-                    bidx = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2;
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    dst.create(sz, CV_MAKETYPE(depth, 1));
+    void yuv_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {yuv_to_bgr_8u, 0, yuv_to_bgr_16u, 0, 0, yuv_to_bgr_32f},
+                {yuv4_to_bgr_8u, 0, yuv4_to_bgr_16u, 0, 0, yuv4_to_bgr_32f}
+            },
+            {
+                {yuv_to_bgra_8u, 0, yuv_to_bgra_16u, 0, 0, yuv_to_bgra_32f},
+                {yuv4_to_bgra_8u, 0, yuv4_to_bgra_16u, 0, 0, yuv4_to_bgra_32f}
+            }
+        };
 
-                    funcs[depth](src, scn, dst, bidx, stream);
-                    break;
-                }
-            
-            case CV_BGR5652GRAY: case CV_BGR5552GRAY:
-                {
-                    CV_Assert(scn == 2 && depth == CV_8U);
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    int green_bits = code == CV_BGR5652GRAY ? 6 : 5;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    dst.create(sz, CV_8UC1);
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+    
+    void rgb_to_YCrCb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_YCrCb_8u, 0, rgb_to_YCrCb_16u, 0, 0, rgb_to_YCrCb_32f},
+                {rgba_to_YCrCb_8u, 0, rgba_to_YCrCb_16u, 0, 0, rgba_to_YCrCb_32f}
+            },
+            {
+                {rgb_to_YCrCb4_8u, 0, rgb_to_YCrCb4_16u, 0, 0, rgb_to_YCrCb4_32f},
+                {rgba_to_YCrCb4_8u, 0, rgba_to_YCrCb4_16u, 0, 0, rgba_to_YCrCb4_32f}
+            }
+        };
 
-                    color::RGB5x52Gray_gpu(src, green_bits, dst, stream);
-                    break;
-                }
-            
-            case CV_GRAY2BGR: case CV_GRAY2BGRA:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream);
-                    static const func_t funcs[] = {color::Gray2RGB_gpu_8u, 0, color::Gray2RGB_gpu_16u, 0, 0, color::Gray2RGB_gpu_32f};
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    if (dcn <= 0) dcn = 3;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    CV_Assert(scn == 1 && (dcn == 3 || dcn == 4));
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+    void bgr_to_YCrCb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_YCrCb_8u, 0, bgr_to_YCrCb_16u, 0, 0, bgr_to_YCrCb_32f},
+                {bgra_to_YCrCb_8u, 0, bgra_to_YCrCb_16u, 0, 0, bgra_to_YCrCb_32f}
+            },
+            {
+                {bgr_to_YCrCb4_8u, 0, bgr_to_YCrCb4_16u, 0, 0, bgr_to_YCrCb4_32f},
+                {bgra_to_YCrCb4_8u, 0, bgra_to_YCrCb4_16u, 0, 0, bgra_to_YCrCb4_32f}
+            }
+        };
 
-                    funcs[depth](src, dst, dcn, stream);
-                    break;
-                }
-                
-            case CV_GRAY2BGR565: case CV_GRAY2BGR555:
-                {
-                    CV_Assert(scn == 1 && depth == CV_8U);
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    int green_bits =  code == CV_GRAY2BGR565 ? 6 : 5;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    dst.create(sz, CV_8UC2);
-                    
-                    color::Gray2RGB5x5_gpu(src, dst, green_bits, stream);
-                    break;
-                }
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-            case CV_BGR2YCrCb: case CV_RGB2YCrCb:
-            case CV_BGR2YUV: case CV_RGB2YUV:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, 
-                        const void* coeffs, cudaStream_t stream);
-                    static const func_t funcs[] = {color::RGB2YCrCb_gpu_8u, 0, color::RGB2YCrCb_gpu_16u, 0, 0, color::RGB2YCrCb_gpu_32f};
+    void YCrCb_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {YCrCb_to_rgb_8u, 0, YCrCb_to_rgb_16u, 0, 0, YCrCb_to_rgb_32f},
+                {YCrCb4_to_rgb_8u, 0, YCrCb4_to_rgb_16u, 0, 0, YCrCb4_to_rgb_32f}
+            },
+            {
+                {YCrCb_to_rgba_8u, 0, YCrCb_to_rgba_16u, 0, 0, YCrCb_to_rgba_32f},
+                {YCrCb4_to_rgba_8u, 0, YCrCb4_to_rgba_16u, 0, 0, YCrCb4_to_rgba_32f}
+            }
+        };
 
-                    if (dcn <= 0) dcn = 3;
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4));
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    bidx = code == CV_BGR2YCrCb || code == CV_RGB2YUV ? 0 : 2;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    static const float yuv_f[] = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
-                    static const int yuv_i[] = { B2Y, G2Y, R2Y, 8061, 14369 };
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    static const float YCrCb_f[] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
-                    static const int YCrCb_i[] = {R2Y, G2Y, B2Y, 11682, 9241};
+    void YCrCb_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {YCrCb_to_bgr_8u, 0, YCrCb_to_bgr_16u, 0, 0, YCrCb_to_bgr_32f},
+                {YCrCb4_to_bgr_8u, 0, YCrCb4_to_bgr_16u, 0, 0, YCrCb4_to_bgr_32f}
+            },
+            {
+                {YCrCb_to_bgra_8u, 0, YCrCb_to_bgra_16u, 0, 0, YCrCb_to_bgra_32f},
+                {YCrCb4_to_bgra_8u, 0, YCrCb4_to_bgra_16u, 0, 0, YCrCb4_to_bgra_32f}
+            }
+        };
 
-                    float coeffs_f[5];
-                    int coeffs_i[5];
-                    ::memcpy(coeffs_f, code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? YCrCb_f : yuv_f, sizeof(yuv_f));
-                    ::memcpy(coeffs_i, code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? YCrCb_i : yuv_i, sizeof(yuv_i));
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    if (bidx == 0) 
-                    {
-                        std::swap(coeffs_f[0], coeffs_f[2]);
-                        std::swap(coeffs_i[0], coeffs_i[2]);
-                    }
-                        
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    const void* coeffs = depth == CV_32F ? (void*)coeffs_f : (void*)coeffs_i;
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    funcs[depth](src, scn, dst, dcn, bidx, coeffs, stream);
-                    break;
-                }
-                
-            case CV_YCrCb2BGR: case CV_YCrCb2RGB:
-            case CV_YUV2BGR: case CV_YUV2RGB:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, 
-                        const void* coeffs, cudaStream_t stream);
-                    static const func_t funcs[] = {color::YCrCb2RGB_gpu_8u, 0, color::YCrCb2RGB_gpu_16u, 0, 0, color::YCrCb2RGB_gpu_32f};
+    void rgb_to_xyz(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_xyz_8u, 0, rgb_to_xyz_16u, 0, 0, rgb_to_xyz_32f},
+                {rgba_to_xyz_8u, 0, rgba_to_xyz_16u, 0, 0, rgba_to_xyz_32f}
+            },
+            {
+                {rgb_to_xyz4_8u, 0, rgb_to_xyz4_16u, 0, 0, rgb_to_xyz4_32f},
+                {rgba_to_xyz4_8u, 0, rgba_to_xyz4_16u, 0, 0, rgba_to_xyz4_32f}
+            }
+        };
 
-                    if (dcn <= 0) dcn = 3;
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4));
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    bidx = code == CV_YCrCb2BGR || code == CV_YUV2RGB ? 0 : 2;
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    static const float yuv_f[] = { 2.032f, -0.395f, -0.581f, 1.140f };
-                    static const int yuv_i[] = { 33292, -6472, -9519, 18678 }; 
+    void bgr_to_xyz(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_xyz_8u, 0, bgr_to_xyz_16u, 0, 0, bgr_to_xyz_32f},
+                {bgra_to_xyz_8u, 0, bgra_to_xyz_16u, 0, 0, bgra_to_xyz_32f}
+            },
+            {
+                {bgr_to_xyz4_8u, 0, bgr_to_xyz4_16u, 0, 0, bgr_to_xyz4_32f},
+                {bgra_to_xyz4_8u, 0, bgra_to_xyz4_16u, 0, 0, bgra_to_xyz4_32f}
+            }
+        };
 
-                    static const float YCrCb_f[] = {1.403f, -0.714f, -0.344f, 1.773f};
-                    static const int YCrCb_i[] = {22987, -11698, -5636, 29049};
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    const float* coeffs_f = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? YCrCb_f : yuv_f;
-                    const int* coeffs_i = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? YCrCb_i : yuv_i;
-                    
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
-                    
-                    const void* coeffs = depth == CV_32F ? (void*)coeffs_f : (void*)coeffs_i;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    funcs[depth](src, scn, dst, dcn, bidx, coeffs, stream);
-                    break;
-                }
-            
-            case CV_BGR2XYZ: case CV_RGB2XYZ:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, 
-                        const void* coeffs, cudaStream_t stream);
-                    static const func_t funcs[] = {color::RGB2XYZ_gpu_8u, 0, color::RGB2XYZ_gpu_16u, 0, 0, color::RGB2XYZ_gpu_32f};
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    if (dcn <= 0) dcn = 3;
+    void xyz_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {xyz_to_rgb_8u, 0, xyz_to_rgb_16u, 0, 0, xyz_to_rgb_32f},
+                {xyz4_to_rgb_8u, 0, xyz4_to_rgb_16u, 0, 0, xyz4_to_rgb_32f}
+            },
+            {
+                {xyz_to_rgba_8u, 0, xyz_to_rgba_16u, 0, 0, xyz_to_rgba_32f},
+                {xyz4_to_rgba_8u, 0, xyz4_to_rgba_16u, 0, 0, xyz4_to_rgba_32f}
+            }
+        };
 
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4));
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    bidx = code == CV_BGR2XYZ ? 0 : 2;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    static const float RGB2XYZ_D65f[] =
-                    {
-                        0.412453f, 0.357580f, 0.180423f,
-                        0.212671f, 0.715160f, 0.072169f,
-                        0.019334f, 0.119193f, 0.950227f
-                    };
-                    static const int RGB2XYZ_D65i[] =
-                    {
-                        1689,    1465,    739,
-                        871,     2929,    296,
-                        79,      488,     3892
-                    };
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    float coeffs_f[9];
-                    int coeffs_i[9];
-                    ::memcpy(coeffs_f, RGB2XYZ_D65f, sizeof(RGB2XYZ_D65f));
-                    ::memcpy(coeffs_i, RGB2XYZ_D65i, sizeof(RGB2XYZ_D65i));
+    void xyz_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {xyz_to_bgr_8u, 0, xyz_to_bgr_16u, 0, 0, xyz_to_bgr_32f},
+                {xyz4_to_bgr_8u, 0, xyz4_to_bgr_16u, 0, 0, xyz4_to_bgr_32f}
+            },
+            {
+                {xyz_to_bgra_8u, 0, xyz_to_bgra_16u, 0, 0, xyz_to_bgra_32f},
+                {xyz4_to_bgra_8u, 0, xyz4_to_bgra_16u, 0, 0, xyz4_to_bgra_32f}
+            }
+        };
 
-                    if (bidx == 0) 
-                    {
-                        std::swap(coeffs_f[0], coeffs_f[2]);
-                        std::swap(coeffs_f[3], coeffs_f[5]);
-                        std::swap(coeffs_f[6], coeffs_f[8]);
-                        
-                        std::swap(coeffs_i[0], coeffs_i[2]);
-                        std::swap(coeffs_i[3], coeffs_i[5]);
-                        std::swap(coeffs_i[6], coeffs_i[8]);
-                    }
-                        
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
-                    
-                    const void* coeffs = depth == CV_32F ? (void*)coeffs_f : (void*)coeffs_i;
-                    
-                    funcs[depth](src, scn, dst, dcn, coeffs, stream);
-                    break;
-                }
-            
-            case CV_XYZ2BGR: case CV_XYZ2RGB:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream);
-                    static const func_t funcs[] = {color::XYZ2RGB_gpu_8u, 0, color::XYZ2RGB_gpu_16u, 0, 0, color::XYZ2RGB_gpu_32f};
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    if (dcn <= 0) dcn = 3;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4));
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    bidx = code == CV_XYZ2BGR ? 0 : 2;
+    void rgb_to_hsv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_hsv_8u, 0, 0, 0, 0, rgb_to_hsv_32f},
+                {rgba_to_hsv_8u, 0, 0, 0, 0, rgba_to_hsv_32f},
+            },
+            {
+                {rgb_to_hsv4_8u, 0, 0, 0, 0, rgb_to_hsv4_32f},
+                {rgba_to_hsv4_8u, 0, 0, 0, 0, rgba_to_hsv4_32f},
+            }
+        };
 
-                    static const float XYZ2sRGB_D65f[] =
-                    {
-                        3.240479f, -1.53715f, -0.498535f,
-                        -0.969256f, 1.875991f, 0.041556f,
-                        0.055648f, -0.204043f, 1.057311f
-                    };
-                    static const int XYZ2sRGB_D65i[] =
-                    {
-                        13273,  -6296,  -2042,
-                        -3970,   7684,    170,
-                          228,   -836,   4331
-                    };
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    float coeffs_f[9];
-                    int coeffs_i[9];
-                    ::memcpy(coeffs_f, XYZ2sRGB_D65f, sizeof(XYZ2sRGB_D65f));
-                    ::memcpy(coeffs_i, XYZ2sRGB_D65i, sizeof(XYZ2sRGB_D65i));
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    if (bidx == 0) 
-                    {
-                        std::swap(coeffs_f[0], coeffs_f[6]);
-                        std::swap(coeffs_f[1], coeffs_f[7]);
-                        std::swap(coeffs_f[2], coeffs_f[8]);
-                        
-                        std::swap(coeffs_i[0], coeffs_i[6]);
-                        std::swap(coeffs_i[1], coeffs_i[7]);
-                        std::swap(coeffs_i[2], coeffs_i[8]);
-                    }
-                        
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
-                    
-                    const void* coeffs = depth == CV_32F ? (void*)coeffs_f : (void*)coeffs_i;
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    funcs[depth](src, scn, dst, dcn, coeffs, stream);
-                    break;
-                }
+    void bgr_to_hsv(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_hsv_8u, 0, 0, 0, 0, bgr_to_hsv_32f},
+                {bgra_to_hsv_8u, 0, 0, 0, 0, bgra_to_hsv_32f}
+            },
+            {
+                {bgr_to_hsv4_8u, 0, 0, 0, 0, bgr_to_hsv4_32f},
+                {bgra_to_hsv4_8u, 0, 0, 0, 0, bgra_to_hsv4_32f}
+            }
+        };
 
-            case CV_BGR2HSV: case CV_RGB2HSV: case CV_BGR2HSV_FULL: case CV_RGB2HSV_FULL:
-            case CV_BGR2HLS: case CV_RGB2HLS: case CV_BGR2HLS_FULL: case CV_RGB2HLS_FULL:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, 
-                        int hrange, cudaStream_t stream);
-                    static const func_t funcs_hsv[] = {color::RGB2HSV_gpu_8u, 0, 0, 0, 0, color::RGB2HSV_gpu_32f};
-                    static const func_t funcs_hls[] = {color::RGB2HLS_gpu_8u, 0, 0, 0, 0, color::RGB2HLS_gpu_32f};
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    if (dcn <= 0) dcn = 3;
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4) && (depth == CV_8U || depth == CV_32F));
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    bidx = code == CV_BGR2HSV || code == CV_BGR2HLS ||
-                        code == CV_BGR2HSV_FULL || code == CV_BGR2HLS_FULL ? 0 : 2;
-                    int hrange = depth == CV_32F ? 360 : code == CV_BGR2HSV || code == CV_RGB2HSV ||
-                        code == CV_BGR2HLS || code == CV_RGB2HLS ? 180 : 256;
-                
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+    void hsv_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hsv_to_rgb_8u, 0, 0, 0, 0, hsv_to_rgb_32f},
+                {hsv4_to_rgb_8u, 0, 0, 0, 0, hsv4_to_rgb_32f}
+            },
+            {
+                {hsv_to_rgba_8u, 0, 0, 0, 0, hsv_to_rgba_32f},
+                {hsv4_to_rgba_8u, 0, 0, 0, 0, hsv4_to_rgba_32f}
+            }
+        };
 
-                    if (code == CV_BGR2HSV || code == CV_RGB2HSV || code == CV_BGR2HSV_FULL || code == CV_RGB2HSV_FULL) 
-                        funcs_hsv[depth](src, scn, dst, dcn, bidx, hrange, stream);
-                    else
-                        funcs_hls[depth](src, scn, dst, dcn, bidx, hrange, stream);
-                    break;
-                }
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-            case CV_HSV2BGR: case CV_HSV2RGB: case CV_HSV2BGR_FULL: case CV_HSV2RGB_FULL:
-            case CV_HLS2BGR: case CV_HLS2RGB: case CV_HLS2BGR_FULL: case CV_HLS2RGB_FULL:
-                {
-                    typedef void (*func_t)(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, 
-                        int hrange, cudaStream_t stream);
-                    static const func_t funcs_hsv[] = {color::HSV2RGB_gpu_8u, 0, 0, 0, 0, color::HSV2RGB_gpu_32f};
-                    static const func_t funcs_hls[] = {color::HLS2RGB_gpu_8u, 0, 0, 0, 0, color::HLS2RGB_gpu_32f};
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-                    if (dcn <= 0) dcn = 3;
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
 
-                    CV_Assert((scn == 3 || scn == 4) && (dcn == 3 || dcn == 4) && (depth == CV_8U || depth == CV_32F));
+    void hsv_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hsv_to_bgr_8u, 0, 0, 0, 0, hsv_to_bgr_32f},
+                {hsv4_to_bgr_8u, 0, 0, 0, 0, hsv4_to_bgr_32f}
+            },
+            {
+                {hsv_to_bgra_8u, 0, 0, 0, 0, hsv_to_bgra_32f},
+                {hsv4_to_bgra_8u, 0, 0, 0, 0, hsv4_to_bgra_32f}
+            }
+        };
 
-                    bidx = code == CV_HSV2BGR || code == CV_HLS2BGR ||
-                        code == CV_HSV2BGR_FULL || code == CV_HLS2BGR_FULL ? 0 : 2;
-                    int hrange = depth == CV_32F ? 360 : code == CV_HSV2BGR || code == CV_HSV2RGB ||
-                        code == CV_HLS2BGR || code == CV_HLS2RGB ? 180 : 255;
-                    
-                    dst.create(sz, CV_MAKETYPE(depth, dcn));
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
 
-                    if (code == CV_HSV2BGR || code == CV_HSV2RGB || code == CV_HSV2BGR_FULL || code == CV_HSV2RGB_FULL)
-                        funcs_hsv[depth](src, scn, dst, dcn, bidx, hrange, stream);
-                    else
-                        funcs_hls[depth](src, scn, dst, dcn, bidx, hrange, stream);
-                    break;
-                }
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
 
-            default:
-                CV_Error( CV_StsBadFlag, "Unknown/unsupported color conversion code" );
-        }
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }    
+
+    void rgb_to_hls(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_hls_8u, 0, 0, 0, 0, rgb_to_hls_32f},
+                {rgba_to_hls_8u, 0, 0, 0, 0, rgba_to_hls_32f},
+            },
+            {
+                {rgb_to_hls4_8u, 0, 0, 0, 0, rgb_to_hls4_32f},
+                {rgba_to_hls4_8u, 0, 0, 0, 0, rgba_to_hls4_32f},
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_hls(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_hls_8u, 0, 0, 0, 0, bgr_to_hls_32f},
+                {bgra_to_hls_8u, 0, 0, 0, 0, bgra_to_hls_32f}
+            },
+            {
+                {bgr_to_hls4_8u, 0, 0, 0, 0, bgr_to_hls4_32f},
+                {bgra_to_hls4_8u, 0, 0, 0, 0, bgra_to_hls4_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hls_to_rgb(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hls_to_rgb_8u, 0, 0, 0, 0, hls_to_rgb_32f},
+                {hls4_to_rgb_8u, 0, 0, 0, 0, hls4_to_rgb_32f}
+            },
+            {
+                {hls_to_rgba_8u, 0, 0, 0, 0, hls_to_rgba_32f},
+                {hls4_to_rgba_8u, 0, 0, 0, 0, hls4_to_rgba_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hls_to_bgr(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hls_to_bgr_8u, 0, 0, 0, 0, hls_to_bgr_32f},
+                {hls4_to_bgr_8u, 0, 0, 0, 0, hls4_to_bgr_32f}
+            },
+            {
+                {hls_to_bgra_8u, 0, 0, 0, 0, hls_to_bgra_32f},
+                {hls4_to_bgra_8u, 0, 0, 0, 0, hls4_to_bgra_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }   
+
+    void rgb_to_hsv_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_hsv_full_8u, 0, 0, 0, 0, rgb_to_hsv_full_32f},
+                {rgba_to_hsv_full_8u, 0, 0, 0, 0, rgba_to_hsv_full_32f},
+            },
+            {
+                {rgb_to_hsv4_full_8u, 0, 0, 0, 0, rgb_to_hsv4_full_32f},
+                {rgba_to_hsv4_full_8u, 0, 0, 0, 0, rgba_to_hsv4_full_32f},
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_hsv_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_hsv_full_8u, 0, 0, 0, 0, bgr_to_hsv_full_32f},
+                {bgra_to_hsv_full_8u, 0, 0, 0, 0, bgra_to_hsv_full_32f}
+            },
+            {
+                {bgr_to_hsv4_full_8u, 0, 0, 0, 0, bgr_to_hsv4_full_32f},
+                {bgra_to_hsv4_full_8u, 0, 0, 0, 0, bgra_to_hsv4_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hsv_to_rgb_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hsv_to_rgb_full_8u, 0, 0, 0, 0, hsv_to_rgb_full_32f},
+                {hsv4_to_rgb_full_8u, 0, 0, 0, 0, hsv4_to_rgb_full_32f}
+            },
+            {
+                {hsv_to_rgba_full_8u, 0, 0, 0, 0, hsv_to_rgba_full_32f},
+                {hsv4_to_rgba_full_8u, 0, 0, 0, 0, hsv4_to_rgba_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hsv_to_bgr_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hsv_to_bgr_full_8u, 0, 0, 0, 0, hsv_to_bgr_full_32f},
+                {hsv4_to_bgr_full_8u, 0, 0, 0, 0, hsv4_to_bgr_full_32f}
+            },
+            {
+                {hsv_to_bgra_full_8u, 0, 0, 0, 0, hsv_to_bgra_full_32f},
+                {hsv4_to_bgra_full_8u, 0, 0, 0, 0, hsv4_to_bgra_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }    
+
+    void rgb_to_hls_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {rgb_to_hls_full_8u, 0, 0, 0, 0, rgb_to_hls_full_32f},
+                {rgba_to_hls_full_8u, 0, 0, 0, 0, rgba_to_hls_full_32f},
+            },
+            {
+                {rgb_to_hls4_full_8u, 0, 0, 0, 0, rgb_to_hls4_full_32f},
+                {rgba_to_hls4_full_8u, 0, 0, 0, 0, rgba_to_hls4_full_32f},
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void bgr_to_hls_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {bgr_to_hls_full_8u, 0, 0, 0, 0, bgr_to_hls_full_32f},
+                {bgra_to_hls_full_8u, 0, 0, 0, 0, bgra_to_hls_full_32f}
+            },
+            {
+                {bgr_to_hls4_full_8u, 0, 0, 0, 0, bgr_to_hls4_full_32f},
+                {bgra_to_hls4_full_8u, 0, 0, 0, 0, bgra_to_hls4_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hls_to_rgb_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hls_to_rgb_full_8u, 0, 0, 0, 0, hls_to_rgb_full_32f},
+                {hls4_to_rgb_full_8u, 0, 0, 0, 0, hls4_to_rgb_full_32f}
+            },
+            {
+                {hls_to_rgba_full_8u, 0, 0, 0, 0, hls_to_rgba_full_32f},
+                {hls4_to_rgba_full_8u, 0, 0, 0, 0, hls4_to_rgba_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
+    }
+
+    void hls_to_bgr_full(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream)
+    {
+        using namespace cv::gpu::color;
+        static const gpu_func_t funcs[2][2][6] = 
+        {
+            {
+                {hls_to_bgr_full_8u, 0, 0, 0, 0, hls_to_bgr_full_32f},
+                {hls4_to_bgr_full_8u, 0, 0, 0, 0, hls4_to_bgr_full_32f}
+            },
+            {
+                {hls_to_bgra_full_8u, 0, 0, 0, 0, hls_to_bgra_full_32f},
+                {hls4_to_bgra_full_8u, 0, 0, 0, 0, hls4_to_bgra_full_32f}
+            }
+        };
+
+        if (dcn <= 0) dcn = 3;
+        
+        CV_Assert(src.depth() == CV_8U || src.depth() == CV_32F);
+        CV_Assert(src.channels() == 3 || src.channels() == 4);
+        CV_Assert(dcn == 3 || dcn == 4);
+
+        dst.create(src.size(), CV_MAKETYPE(src.depth(), dcn));        
+
+        funcs[dcn == 4][src.channels() == 4][src.depth()](src, dst, StreamAccessor::getStream(stream));
     }
 }
 
 void cv::gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, Stream& stream)
 {
-    cvtColor_caller(src, dst, code, dcn, StreamAccessor::getStream(stream));
+    typedef void (*func_t)(const GpuMat& src, GpuMat& dst, int dcn, Stream& stream);
+    static const func_t funcs[] = 
+    {
+        bgr_to_bgra,            // CV_BGR2BGRA    =0
+        bgra_to_bgr,            // CV_BGRA2BGR    =1
+        bgr_to_rgba,            // CV_BGR2RGBA    =2
+        bgra_to_rgb,            // CV_RGBA2BGR    =3
+        bgr_to_rgb,             // CV_BGR2RGB     =4
+        bgra_to_rgba,           // CV_BGRA2RGBA   =5
+
+        bgr_to_gray,            // CV_BGR2GRAY    =6
+        rgb_to_gray,            // CV_RGB2GRAY    =7
+        gray_to_bgr,            // CV_GRAY2BGR    =8
+        gray_to_bgra,           // CV_GRAY2BGRA   =9
+        bgra_to_gray,           // CV_BGRA2GRAY   =10
+        rgba_to_gray,           // CV_RGBA2GRAY   =11
+
+        bgr_to_bgr565,          // CV_BGR2BGR565  =12
+        rgb_to_bgr565,          // CV_RGB2BGR565  =13
+        bgr565_to_bgr,          // CV_BGR5652BGR  =14
+        bgr565_to_rgb,          // CV_BGR5652RGB  =15
+        bgra_to_bgr565,         // CV_BGRA2BGR565 =16
+        rgba_to_bgr565,         // CV_RGBA2BGR565 =17
+        bgr565_to_bgra,         // CV_BGR5652BGRA =18
+        bgr565_to_rgba,         // CV_BGR5652RGBA =19
+
+        gray_to_bgr565,         // CV_GRAY2BGR565 =20
+        bgr565_to_gray,         // CV_BGR5652GRAY =21
+
+        bgr_to_bgr555,          // CV_BGR2BGR555  =22
+        rgb_to_bgr555,          // CV_RGB2BGR555  =23
+        bgr555_to_bgr,          // CV_BGR5552BGR  =24
+        bgr555_to_rgb,          // CV_BGR5552RGB  =25
+        bgra_to_bgr555,         // CV_BGRA2BGR555 =26
+        rgba_to_bgr555,         // CV_RGBA2BGR555 =27
+        bgr555_to_bgra,         // CV_BGR5552BGRA =28
+        bgr555_to_rgba,         // CV_BGR5552RGBA =29
+
+        gray_to_bgr555,         // CV_GRAY2BGR555 =30
+        bgr555_to_gray,         // CV_BGR5552GRAY =31
+
+        bgr_to_xyz,             // CV_BGR2XYZ     =32
+        rgb_to_xyz,             // CV_RGB2XYZ     =33
+        xyz_to_bgr,             // CV_XYZ2BGR     =34
+        xyz_to_rgb,             // CV_XYZ2RGB     =35
+
+        bgr_to_YCrCb,           // CV_BGR2YCrCb   =36
+        rgb_to_YCrCb,           // CV_RGB2YCrCb   =37
+        YCrCb_to_bgr,           // CV_YCrCb2BGR   =38
+        YCrCb_to_rgb,           // CV_YCrCb2RGB   =39
+
+        bgr_to_hsv,             // CV_BGR2HSV     =40
+        rgb_to_hsv,             // CV_RGB2HSV     =41
+
+        0,                      //                =42
+        0,                      //                =43
+
+        0,                      // CV_BGR2Lab     =44 
+        0,                      // CV_RGB2Lab     =45
+
+        0,                      // CV_BayerBG2BGR =46
+        0,                      // CV_BayerGB2BGR =47
+        0,                      // CV_BayerRG2BGR =48
+        0,                      // CV_BayerGR2BGR =49
+
+        0,                      // CV_BGR2Luv     =50
+        0,                      // CV_RGB2Luv     =51
+
+        bgr_to_hls,             // CV_BGR2HLS     =52
+        rgb_to_hls,             // CV_RGB2HLS     =53
+
+        hsv_to_bgr,             // CV_HSV2BGR     =54
+        bgr_to_rgb,             // CV_HSV2RGB     =55
+
+        0,                      // CV_Lab2BGR     =56
+        0,                      // CV_Lab2RGB     =57
+        0,                      // CV_Luv2BGR     =58
+        0,                      // CV_Luv2RGB     =59
+        
+        hls_to_bgr,             // CV_HLS2BGR     =60
+        hls_to_rgb,             // CV_HLS2RGB     =61
+
+        0,                      // CV_BayerBG2BGR_VNG =62
+        0,                      // CV_BayerGB2BGR_VNG =63
+        0,                      // CV_BayerRG2BGR_VNG =64
+        0,                      // CV_BayerGR2BGR_VNG =65
+
+        bgr_to_hsv_full,        // CV_BGR2HSV_FULL = 66
+        rgb_to_hsv_full,        // CV_RGB2HSV_FULL = 67
+        bgr_to_hls_full,        // CV_BGR2HLS_FULL = 68
+        rgb_to_hls_full,        // CV_RGB2HLS_FULL = 69
+
+        hsv_to_bgr_full,        // CV_HSV2BGR_FULL = 70
+        hsv_to_rgb_full,        // CV_HSV2RGB_FULL = 71
+        hls_to_bgr_full,        // CV_HLS2BGR_FULL = 72
+        hls_to_rgb_full,        // CV_HLS2RGB_FULL = 73
+
+        0,                      // CV_LBGR2Lab     = 74
+        0,                      // CV_LRGB2Lab     = 75
+        0,                      // CV_LBGR2Luv     = 76
+        0,                      // CV_LRGB2Luv     = 77
+
+        0,                      // CV_Lab2LBGR     = 78
+        0,                      // CV_Lab2LRGB     = 79
+        0,                      // CV_Luv2LBGR     = 80
+        0,                      // CV_Luv2LRGB     = 81
+
+        bgr_to_yuv,             // CV_BGR2YUV      = 82
+        rgb_to_yuv,             // CV_RGB2YUV      = 83
+        yuv_to_bgr,             // CV_YUV2BGR      = 84
+        yuv_to_rgb,             // CV_YUV2RGB      = 85
+
+        0,                      // CV_BayerBG2GRAY = 86
+        0,                      // CV_BayerGB2GRAY = 87
+        0,                      // CV_BayerRG2GRAY = 88
+        0,                      // CV_BayerGR2GRAY = 89
+
+        0,                      // CV_YUV420i2RGB  = 90
+        0,                      // CV_YUV420i2BGR  = 91
+        0,                      // CV_YUV420sp2RGB = 92
+        0                       // CV_YUV420sp2BGR = 93
+    };
+
+    CV_Assert(code < 94);
+
+    func_t func = funcs[code];
+
+    if (func == 0)
+        CV_Error( CV_StsBadFlag, "Unknown/unsupported color conversion code" );
+
+    func(src, dst, dcn, stream);
 }
 
 #endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/src/cuda/brute_force_matcher.cu b/modules/gpu/src/cuda/brute_force_matcher.cu
index fa06589f3a..6b1361901c 100644
--- a/modules/gpu/src/cuda/brute_force_matcher.cu
+++ b/modules/gpu/src/cuda/brute_force_matcher.cu
@@ -41,7 +41,7 @@
 //M*/
 
 #include "internal_shared.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
 
 using namespace cv::gpu;
@@ -56,9 +56,8 @@ namespace cv { namespace gpu { namespace bfmatcher
     ///////////////////////////////////////////////////////////////////////////////
     // Mask strategy
 
-    class SingleMask
+    struct SingleMask
     {
-    public:
         explicit SingleMask(const PtrStep& mask_) : mask(mask_) {}
         
         __device__ __forceinline__ bool operator()(int queryIdx, int trainIdx) const
@@ -66,13 +65,11 @@ namespace cv { namespace gpu { namespace bfmatcher
             return mask.ptr(queryIdx)[trainIdx] != 0;
         }
 
-    private:
-        PtrStep mask;
+        const PtrStep mask;
     };
 
-    class MaskCollection
+    struct MaskCollection
     {
-    public:
         explicit MaskCollection(PtrStep* maskCollection_) : maskCollection(maskCollection_) {}
 
         __device__ __forceinline__ void nextMask()
@@ -86,15 +83,14 @@ namespace cv { namespace gpu { namespace bfmatcher
             return curMask.data == 0 || (ForceGlob<uchar>::Load(curMask.ptr(queryIdx), trainIdx, val), (val != 0));
         }
 
-    private:
-        PtrStep* maskCollection;
+        const PtrStep* maskCollection;
         PtrStep curMask;
     };
 
     class WithOutMask
     {
     public:
-        __device__ __forceinline__ void nextMask()
+        __device__ __forceinline__ void nextMask() const
         {
         }
         __device__ __forceinline__ bool operator()(int queryIdx, int trainIdx) const
@@ -128,9 +124,8 @@ namespace cv { namespace gpu { namespace bfmatcher
     ///////////////////////////////////////////////////////////////////////////////
     // Distance
 
-    template <typename T> class L1Dist
+    template <typename T> struct L1Dist
     {
-    public:
         typedef int ResultType;
         typedef int ValueType;
 
@@ -151,12 +146,10 @@ namespace cv { namespace gpu { namespace bfmatcher
             return mySum;
         }
 
-    private:
         int mySum;
     };
-    template <> class L1Dist<float>
+    template <> struct L1Dist<float>
     {
-    public:
         typedef float ResultType;
         typedef float ValueType;
 
@@ -177,13 +170,11 @@ namespace cv { namespace gpu { namespace bfmatcher
             return mySum;
         }
 
-    private:
         float mySum;
     };
 
-    class L2Dist
+    struct L2Dist
     {
-    public:
         typedef float ResultType;
         typedef float ValueType;
 
@@ -205,13 +196,11 @@ namespace cv { namespace gpu { namespace bfmatcher
             return sqrtf(mySum);
         }
 
-    private:
         float mySum;
     };
 
-    class HammingDist
+    struct HammingDist
     {
-    public:
         typedef int ResultType;
         typedef int ValueType;
 
@@ -232,7 +221,6 @@ namespace cv { namespace gpu { namespace bfmatcher
             return mySum;
         }
 
-    private:
         int mySum;
     };
     
@@ -425,10 +413,8 @@ namespace cv { namespace gpu { namespace bfmatcher
     ///////////////////////////////////////////////////////////////////////////////
     // ReduceDescCalculator
 
-    template <int BLOCK_DIM_X, typename T>
-    class ReduceDescCalculatorSimple
+    template <int BLOCK_DIM_X, typename T> struct ReduceDescCalculatorSimple
     {
-    public:
         __device__ __forceinline__ void prepare(const T* queryDescs_, int, void*)
         {
             queryDescs = queryDescs_;
@@ -440,14 +426,12 @@ namespace cv { namespace gpu { namespace bfmatcher
             reduceDescDiff<BLOCK_DIM_X>(queryDescs, trainDescs, desc_len, dist, sdiff_row);
         }
 
-    private:
         const T* queryDescs;
     };
 
     template <int BLOCK_DIM_X, int MAX_DESCRIPTORS_LEN, bool DESC_LEN_EQ_MAX_LEN, typename T, typename U>
-    class ReduceDescCalculatorCached
+    struct ReduceDescCalculatorCached
     {
-    public:
         __device__ __forceinline__ void prepare(const T* queryDescs, int desc_len, U* smem)
         {
             loadDescsVals<BLOCK_DIM_X, MAX_DESCRIPTORS_LEN>(queryDescs, desc_len, queryVals, smem);
@@ -459,7 +443,6 @@ namespace cv { namespace gpu { namespace bfmatcher
             reduceDescDiffCached<BLOCK_DIM_X, MAX_DESCRIPTORS_LEN, DESC_LEN_EQ_MAX_LEN>(queryVals, trainDescs, desc_len, dist, sdiff_row);
         }
 
-    private:
         U queryVals[MAX_DESCRIPTORS_LEN / BLOCK_DIM_X];
     };
     
@@ -497,10 +480,8 @@ namespace cv { namespace gpu { namespace bfmatcher
     ///////////////////////////////////////////////////////////////////////////////
     // Train collection loop strategy
 
-    template <typename T>
-    class SingleTrain
+    template <typename T> struct SingleTrain
     {
-    public:
         explicit SingleTrain(const DevMem2D_<T>& trainDescs_) : trainDescs(trainDescs_)
         {
         }
@@ -517,14 +498,11 @@ namespace cv { namespace gpu { namespace bfmatcher
             return trainDescs.cols;
         }
 
-    private:
-        DevMem2D_<T> trainDescs;
+        const DevMem2D_<T> trainDescs;
     };
 
-    template <typename T>
-    class TrainCollection
+    template <typename T> struct TrainCollection
     {
-    public:
         TrainCollection(const DevMem2D_<T>* trainCollection_, int nImg_, int desclen_) : 
             trainCollection(trainCollection_), nImg(nImg_), desclen(desclen_)
         {
@@ -536,7 +514,7 @@ namespace cv { namespace gpu { namespace bfmatcher
         {
             for (int imgIdx = 0; imgIdx < nImg; ++imgIdx)
             {
-                DevMem2D_<T> trainDescs = trainCollection[imgIdx];
+                const DevMem2D_<T> trainDescs = trainCollection[imgIdx];
                 m.nextMask();
                 matchDescs<Dist>(queryIdx, imgIdx, trainDescs, m, reduceDescCalc, myMin, myBestTrainIdx, myBestImgIdx, sdiff_row);
             }
@@ -547,7 +525,6 @@ namespace cv { namespace gpu { namespace bfmatcher
             return desclen;
         }
 
-    private:
         const DevMem2D_<T>* trainCollection;
         int nImg;
         int desclen;
@@ -565,7 +542,7 @@ namespace cv { namespace gpu { namespace bfmatcher
         
         int myBestTrainIdx = -1;
         int myBestImgIdx = -1;
-        typename Dist::ResultType myMin = numeric_limits_gpu<typename Dist::ResultType>::max();
+        typename Dist::ResultType myMin = numeric_limits<typename Dist::ResultType>::max();
 
         {
             typename Dist::ResultType* sdiff_row = smem + BLOCK_DIM_X * threadIdx.y;
@@ -646,9 +623,9 @@ namespace cv { namespace gpu { namespace bfmatcher
             matchCached_caller<16, 16, 64, true, Dist>(queryDescs, train, mask, trainIdx, imgIdx, distance, stream);
         else if (queryDescs.cols < 128)
             matchCached_caller<16, 16, 128, false, Dist>(queryDescs, train, mask, trainIdx, imgIdx, distance, stream);
-        else if (queryDescs.cols == 128)
+        else if (queryDescs.cols == 128 && cc_12)
             matchCached_caller<16, 16, 128, true, Dist>(queryDescs, train, mask, trainIdx, imgIdx, distance, stream);
-        else if (queryDescs.cols < 256)
+        else if (queryDescs.cols < 256 && cc_12)
             matchCached_caller<16, 16, 256, false, Dist>(queryDescs, train, mask, trainIdx, imgIdx, distance, stream);
         else if (queryDescs.cols == 256 && cc_12)
             matchCached_caller<16, 16, 256, true, Dist>(queryDescs, train, mask, trainIdx, imgIdx, distance, stream);
@@ -806,7 +783,7 @@ namespace cv { namespace gpu { namespace bfmatcher
     // Calc distance kernel
 
     template <int BLOCK_DIM_X, int BLOCK_DIM_Y, typename Dist, typename T, typename Mask>
-    __global__ void calcDistance(PtrStep_<T> queryDescs_, DevMem2D_<T> trainDescs_, Mask mask, PtrStepf distance)
+    __global__ void calcDistance(const PtrStep_<T> queryDescs_, const DevMem2D_<T> trainDescs_, const Mask mask, PtrStepf distance)
     {
         __shared__ typename Dist::ResultType sdiff[BLOCK_DIM_X * BLOCK_DIM_Y];
 
@@ -821,7 +798,7 @@ namespace cv { namespace gpu { namespace bfmatcher
         {
             const T* trainDescs = trainDescs_.ptr(trainIdx);
 
-            typename Dist::ResultType myDist = numeric_limits_gpu<typename Dist::ResultType>::max();
+            typename Dist::ResultType myDist = numeric_limits<typename Dist::ResultType>::max();
 
             if (mask(queryIdx, trainIdx))
             {
@@ -932,7 +909,7 @@ namespace cv { namespace gpu { namespace bfmatcher
     {
         const int tid = threadIdx.x;
         
-        T myMin = numeric_limits_gpu<T>::max();
+        T myMin = numeric_limits<T>::max();
         int myMinIdx = -1;
 
         for (int i = tid; i < n; i += BLOCK_SIZE)
@@ -989,8 +966,7 @@ namespace cv { namespace gpu { namespace bfmatcher
     ///////////////////////////////////////////////////////////////////////////////
     // find knn match kernel
 
-    template <int BLOCK_SIZE>
-    __global__ void findBestMatch(DevMem2Df allDist_, int i, PtrStepi trainIdx_, PtrStepf distance_)
+    template <int BLOCK_SIZE> __global__ void findBestMatch(DevMem2Df allDist_, int i, PtrStepi trainIdx_, PtrStepf distance_)
     {
         const int SMEM_SIZE = BLOCK_SIZE > 64 ? BLOCK_SIZE : 64;
         __shared__ float sdist[SMEM_SIZE];
@@ -1007,10 +983,10 @@ namespace cv { namespace gpu { namespace bfmatcher
         if (threadIdx.x == 0)
         {
             float dist = sdist[0];
-            if (dist < numeric_limits_gpu<float>::max())
+            if (dist < numeric_limits<float>::max())
             {
                 int bestIdx = strainIdx[0];
-                allDist[bestIdx] = numeric_limits_gpu<float>::max();
+                allDist[bestIdx] = numeric_limits<float>::max();
                 trainIdx[i] = bestIdx;
                 distance[i] = dist;
             }
@@ -1130,8 +1106,8 @@ namespace cv { namespace gpu { namespace bfmatcher
     // Radius Match kernel
 
     template <int BLOCK_DIM_X, int BLOCK_DIM_Y, typename Dist, typename T, typename Mask>
-    __global__ void radiusMatch(PtrStep_<T> queryDescs_, DevMem2D_<T> trainDescs_, 
-        float maxDistance, Mask mask, DevMem2Di trainIdx_, unsigned int* nMatches, PtrStepf distance)
+    __global__ void radiusMatch(const PtrStep_<T> queryDescs_, const DevMem2D_<T> trainDescs_, 
+        float maxDistance, const Mask mask, DevMem2Di trainIdx_, unsigned int* nMatches, PtrStepf distance)
     {
         #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
 
diff --git a/modules/gpu/src/cuda/calib3d.cu b/modules/gpu/src/cuda/calib3d.cu
index fedb3504b7..2a30393817 100644
--- a/modules/gpu/src/cuda/calib3d.cu
+++ b/modules/gpu/src/cuda/calib3d.cu
@@ -42,9 +42,12 @@
 
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/functional.hpp"
 
 #define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
 
+using namespace cv::gpu::device;
+
 namespace cv { namespace gpu
 {
     namespace transform_points
@@ -54,9 +57,9 @@ namespace cv { namespace gpu
         __constant__ float3 crot2;
         __constant__ float3 ctransl;
 
-        struct TransformOp
+        struct TransformOp : unary_function<float3, float3>
         {
-            __device__ __forceinline__ float3 operator()(float3 p) const
+            __device__ __forceinline__ float3 operator()(const float3& p) const
             {
                 return make_float3(
                         crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
@@ -87,9 +90,9 @@ namespace cv { namespace gpu
         __constant__ float3 cproj0;
         __constant__ float3 cproj1;
 
-        struct ProjectOp
+        struct ProjectOp : unary_function<float3, float3>
         {
-            __device__ __forceinline__ float2 operator()(float3 p) const
+            __device__ __forceinline__ float2 operator()(const float3& p) const
             {
                 // Rotate and translate in 3D
                 float3 t = make_float3(
diff --git a/modules/gpu/src/cuda/canny.cu b/modules/gpu/src/cuda/canny.cu
new file mode 100644
index 0000000000..19f9b384c4
--- /dev/null
+++ b/modules/gpu/src/cuda/canny.cu
@@ -0,0 +1,491 @@
+/*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*/
+
+#include <utility>
+#include "internal_shared.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace cv { namespace gpu { namespace canny
+{
+    __global__ void calcSobelRowPass(const PtrStep src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+    {
+        __shared__ int smem[16][18];
+
+        const int j = blockIdx.x * blockDim.x + threadIdx.x;
+        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (i < rows)
+        {
+            smem[threadIdx.y][threadIdx.x + 1] = src.ptr(i)[j];
+            if (threadIdx.x == 0)
+            {
+                smem[threadIdx.y][0] = src.ptr(i)[max(j - 1, 0)];
+                smem[threadIdx.y][17] = src.ptr(i)[min(j + 16, cols - 1)];
+            }
+            __syncthreads();
+
+            if (j < cols)
+            {
+                dx_buf.ptr(i)[j] = -smem[threadIdx.y][threadIdx.x] + smem[threadIdx.y][threadIdx.x + 2];
+                dy_buf.ptr(i)[j] = smem[threadIdx.y][threadIdx.x] + 2 * smem[threadIdx.y][threadIdx.x + 1] + smem[threadIdx.y][threadIdx.x + 2];
+            }
+        }
+    }
+
+    void calcSobelRowPass_gpu(PtrStep src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        calcSobelRowPass<<<grid, block>>>(src, dx_buf, dy_buf, rows, cols);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+    struct L1
+    {
+        static __device__ __forceinline__ float calc(int x, int y)
+        {
+            return abs(x) + abs(y);
+        }
+    };
+    struct L2
+    {
+        static __device__ __forceinline__ float calc(int x, int y)
+        {
+            return sqrtf(x * x + y * y);
+        }
+    };
+
+    template <typename Norm> __global__ void calcMagnitude(const PtrStepi dx_buf, const PtrStepi dy_buf, 
+        PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+    {
+        __shared__ int sdx[18][16];
+        __shared__ int sdy[18][16];
+
+        const int j = blockIdx.x * blockDim.x + threadIdx.x;
+        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (j < cols)
+        {
+            sdx[threadIdx.y + 1][threadIdx.x] = dx_buf.ptr(i)[j];
+            sdy[threadIdx.y + 1][threadIdx.x] = dy_buf.ptr(i)[j];
+            if (threadIdx.y == 0)
+            {
+                sdx[0][threadIdx.x] = dx_buf.ptr(max(i - 1, 0))[j];
+                sdx[17][threadIdx.x] = dx_buf.ptr(min(i + 16, rows - 1))[j];
+
+                sdy[0][threadIdx.x] = dy_buf.ptr(max(i - 1, 0))[j];
+                sdy[17][threadIdx.x] = dy_buf.ptr(min(i + 16, rows - 1))[j];
+            }
+            __syncthreads();
+
+            if (i < rows)
+            {
+                int x = sdx[threadIdx.y][threadIdx.x] + 2 * sdx[threadIdx.y + 1][threadIdx.x] + sdx[threadIdx.y + 2][threadIdx.x];
+                int y = -sdy[threadIdx.y][threadIdx.x] + sdy[threadIdx.y + 2][threadIdx.x];
+
+                dx.ptr(i)[j] = x;
+                dy.ptr(i)[j] = y;
+
+                mag.ptr(i + 1)[j + 1] = Norm::calc(x, y);
+            }
+        }
+    }
+
+    void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        if (L2Grad)
+            calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+        else
+            calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+    template <typename Norm> __global__ void calcMagnitude(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+    {
+        const int j = blockIdx.x * blockDim.x + threadIdx.x;
+        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (i < rows && j < cols)
+            mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
+    }
+
+    void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        if (L2Grad)
+            calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
+        else
+            calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+//////////////////////////////////////////////////////////////////////////////////////////
+        
+#define CANNY_SHIFT 15
+#define TG22        (int)(0.4142135623730950488016887242097*(1<<CANNY_SHIFT) + 0.5)
+
+    __global__ void calcMap(const PtrStepi dx, const PtrStepi dy, const PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+    {
+        __shared__ float smem[18][18];
+
+        const int j = blockIdx.x * 16 + threadIdx.x;
+        const int i = blockIdx.y * 16 + threadIdx.y;
+
+        const int tid = threadIdx.y * 16 + threadIdx.x;
+        const int lx = tid % 18;
+        const int ly = tid / 18;
+
+        if (ly < 14)
+            smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+
+        if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
+            smem[ly + 14][lx] = mag.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
+
+        __syncthreads();
+
+        if (i < rows && j < cols)
+        {
+            int x = dx.ptr(i)[j];
+            int y = dy.ptr(i)[j];
+            const int s = (x ^ y) < 0 ? -1 : 1;
+            const float m = smem[threadIdx.y + 1][threadIdx.x + 1];
+
+            x = abs(x);
+            y = abs(y);
+
+            // 0 - the pixel can not belong to an edge
+            // 1 - the pixel might belong to an edge
+            // 2 - the pixel does belong to an edge
+            int edge_type = 0;
+
+            if (m > low_thresh)
+            {
+                const int tg22x = x * TG22;
+                const int tg67x = tg22x + ((x + x) << CANNY_SHIFT);
+
+                y <<= CANNY_SHIFT;
+
+                if (y < tg22x)
+                {
+                    if (m > smem[threadIdx.y + 1][threadIdx.x] && m >= smem[threadIdx.y + 1][threadIdx.x + 2])
+                        edge_type = 1 + (int)(m > high_thresh);
+                }
+                else if( y > tg67x )
+                {
+                    if (m > smem[threadIdx.y][threadIdx.x + 1] && m >= smem[threadIdx.y + 2][threadIdx.x + 1])
+                        edge_type = 1 + (int)(m > high_thresh);
+                }
+                else
+                {
+                    if (m > smem[threadIdx.y][threadIdx.x + 1 - s] && m > smem[threadIdx.y + 2][threadIdx.x + 1 + s])
+                        edge_type = 1 + (int)(m > high_thresh);
+                }
+            }
+            
+            map.ptr(i + 1)[j + 1] = edge_type;
+        }
+    }
+
+#undef CANNY_SHIFT
+#undef TG22
+
+    void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+    __device__ unsigned int counter = 0;
+
+    __global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
+    {
+        #if __CUDA_ARCH__ >= 120
+
+        __shared__ int smem[18][18];
+
+        const int j = blockIdx.x * 16 + threadIdx.x;
+        const int i = blockIdx.y * 16 + threadIdx.y;
+
+        const int tid = threadIdx.y * 16 + threadIdx.x;
+        const int lx = tid % 18;
+        const int ly = tid / 18; 
+
+        if (ly < 14)
+            smem[ly][lx] = map.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+
+        if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
+            smem[ly + 14][lx] = map.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
+
+        __syncthreads();
+
+        if (i < rows && j < cols)
+        {
+            int n;
+
+            #pragma unroll
+            for (int k = 0; k < 16; ++k)
+            {
+                n = 0;
+
+                if (smem[threadIdx.y + 1][threadIdx.x + 1] == 1)
+                {
+                    n += smem[threadIdx.y    ][threadIdx.x    ] == 2;
+                    n += smem[threadIdx.y    ][threadIdx.x + 1] == 2;
+                    n += smem[threadIdx.y    ][threadIdx.x + 2] == 2;
+                    
+                    n += smem[threadIdx.y + 1][threadIdx.x    ] == 2;
+                    n += smem[threadIdx.y + 1][threadIdx.x + 2] == 2;
+                    
+                    n += smem[threadIdx.y + 2][threadIdx.x    ] == 2;
+                    n += smem[threadIdx.y + 2][threadIdx.x + 1] == 2;
+                    n += smem[threadIdx.y + 2][threadIdx.x + 2] == 2;
+                }
+
+                if (n > 0)
+                    smem[threadIdx.y + 1][threadIdx.x + 1] = 2;
+            }
+
+            const int e = smem[threadIdx.y + 1][threadIdx.x + 1];
+
+            map.ptr(i + 1)[j + 1] = e;
+
+            n = 0;
+
+            if (e == 2)
+            {
+                n += smem[threadIdx.y    ][threadIdx.x    ] == 1;
+                n += smem[threadIdx.y    ][threadIdx.x + 1] == 1;
+                n += smem[threadIdx.y    ][threadIdx.x + 2] == 1;
+                
+                n += smem[threadIdx.y + 1][threadIdx.x    ] == 1;
+                n += smem[threadIdx.y + 1][threadIdx.x + 2] == 1;
+                
+                n += smem[threadIdx.y + 2][threadIdx.x    ] == 1;
+                n += smem[threadIdx.y + 2][threadIdx.x + 1] == 1;
+                n += smem[threadIdx.y + 2][threadIdx.x + 2] == 1;
+            }
+
+            if (n > 0)
+            {
+                const unsigned int ind = atomicInc(&counter, (unsigned int)(-1));
+                st[ind] = make_ushort2(j + 1, i + 1);
+            }
+        }
+
+        #endif
+    }
+
+    void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        edgesHysteresisLocal<<<grid, block>>>(map, st1, rows, cols);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+    __constant__ int c_dx[8] = {-1,  0,  1, -1, 1, -1, 0, 1};
+    __constant__ int c_dy[8] = {-1, -1, -1,  0, 0,  1, 1, 1};
+
+    __global__ void edgesHysteresisGlobal(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols, int count)
+    {
+        #if __CUDA_ARCH__ >= 120
+
+        const int stack_size = 512;
+        
+        __shared__ unsigned int s_counter;
+        __shared__ unsigned int s_ind;
+        __shared__ ushort2 s_st[stack_size];
+
+        if (threadIdx.x == 0)
+            s_counter = 0;
+        __syncthreads();
+
+        int ind = blockIdx.y * gridDim.x + blockIdx.x;
+
+        if (ind < count)
+        {
+            ushort2 pos = st1[ind];
+
+            if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+            {
+                if (threadIdx.x < 8)
+                {
+                    pos.x += c_dx[threadIdx.x];
+                    pos.y += c_dy[threadIdx.x];
+
+                    if (map.ptr(pos.y)[pos.x] == 1)
+                    {
+                        map.ptr(pos.y)[pos.x] = 2;
+
+                        ind = atomicInc(&s_counter, (unsigned int)(-1));
+
+                        s_st[ind] = pos;
+                    }
+                }
+                __syncthreads();
+
+                while (s_counter > 0 && s_counter <= stack_size - blockDim.x)
+                {
+                    const int subTaskIdx = threadIdx.x >> 3;
+                    const int portion = min(s_counter, blockDim.x >> 3);
+
+                    pos.x = pos.y = 0;
+
+                    if (subTaskIdx < portion)
+                        pos = s_st[s_counter - 1 - subTaskIdx];
+                    __syncthreads();
+                        
+                    if (threadIdx.x == 0)
+                        s_counter -= portion;
+                    __syncthreads();
+                     
+                    if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+                    {
+                        pos.x += c_dx[threadIdx.x & 7];
+                        pos.y += c_dy[threadIdx.x & 7];
+
+                        if (map.ptr(pos.y)[pos.x] == 1)
+                        {
+                            map.ptr(pos.y)[pos.x] = 2;
+
+                            ind = atomicInc(&s_counter, (unsigned int)(-1));
+
+                            s_st[ind] = pos;
+                        }
+                    }
+                    __syncthreads();
+                }
+
+                if (s_counter > 0)
+                {
+                    if (threadIdx.x == 0)
+                    {
+                        ind = atomicAdd(&counter, s_counter);
+                        s_ind = ind - s_counter;
+                    }
+                    __syncthreads();
+
+                    ind = s_ind;
+
+                    for (int i = threadIdx.x; i < s_counter; i += blockDim.x)
+                    {
+                        st2[ind + i] = s_st[i];
+                    }
+                }
+            }
+        }
+
+        #endif
+    }
+
+    void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
+    {
+        void* counter_ptr;
+        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, "cv::gpu::canny::counter") );
+        
+        unsigned int count;
+        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+
+        while (count > 0)
+        {
+            cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
+
+            dim3 block(128, 1, 1);
+            dim3 grid(min(count, 65535u), divUp(count, 65535), 1);
+            edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall(cudaThreadSynchronize());
+
+            cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+
+            std::swap(st1, st2);
+        }
+    }
+
+    __global__ void getEdges(PtrStepi map, PtrStep dst, int rows, int cols)
+    {
+        const int j = blockIdx.x * 16 + threadIdx.x;
+        const int i = blockIdx.y * 16 + threadIdx.y;
+
+        if (i < rows && j < cols)
+            dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
+    }
+
+    void getEdges_gpu(PtrStepi map, PtrStep dst, int rows, int cols)
+    {
+        dim3 block(16, 16, 1);
+        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+        getEdges<<<grid, block>>>(map, dst, rows, cols);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+}}}
diff --git a/modules/gpu/src/cuda/color.cu b/modules/gpu/src/cuda/color.cu
index 9fcd520619..2755fffba8 100644
--- a/modules/gpu/src/cuda/color.cu
+++ b/modules/gpu/src/cuda/color.cu
@@ -41,1305 +41,168 @@
 //M*/
 
 #include "internal_shared.hpp"
-#include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
 #include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/color.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-#ifndef CV_DESCALE
-#define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))
-#endif
-
 namespace cv { namespace gpu { namespace color
 {
-    template<typename T> struct ColorChannel
-    {
-        typedef float worktype_f;
-        static __device__ __forceinline__ T max() { return numeric_limits_gpu<T>::max(); }
-        static __device__ __forceinline__ T half() { return (T)(max()/2 + 1); }
-    };
-    template<> struct ColorChannel<float>
-    {
-        typedef float worktype_f;
-        static __device__ __forceinline__ float max() { return 1.f; }
-        static __device__ __forceinline__ float half() { return 0.5f; }
-    };
-
-    template <typename T>
-    __device__ __forceinline__ void setAlpha(typename TypeVec<T, 3>::vec_t& vec, T val)
-    {
-    }
-    template <typename T>
-    __device__ __forceinline__ void setAlpha(typename TypeVec<T, 4>::vec_t& vec, T val)
-    {
-        vec.w = val;
-    }
-    template <typename T>
-    __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 3>::vec_t& vec)
-    {
-        return ColorChannel<T>::max();
-    }
-    template <typename T>
-    __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 4>::vec_t& vec)
-    {
-        return vec.w;
-    }
-
-    template <typename Cvt>
-    void callConvert(const DevMem2D& src, const DevMem2D& dst, const Cvt& cvt, cudaStream_t stream)
-    {
-        typedef typename Cvt::src_t src_t;
-        typedef typename Cvt::dst_t dst_t;
-
-        transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, cvt, stream);
-    }
-
-////////////////// Various 3/4-channel to 3/4-channel RGB transformations /////////////////
-
-    template <typename T, int SRCCN, int DSTCN>
-    struct RGB2RGB
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        explicit RGB2RGB(int bidx) : bidx(bidx) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-
-            dst.x = (&src.x)[bidx];
-            dst.y = src.y;
-            dst.z = (&src.x)[bidx ^ 2];
-            setAlpha(dst, getAlpha<T>(src));
-
-            return dst;
+    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
+        void name(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream) \
+        { \
+            traits::functor_type functor = traits::create_functor(); \
+            typedef typename traits::functor_type::argument_type src_t; \
+            typedef typename traits::functor_type::result_type   dst_t; \
+            transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, functor, stream); \
         }
 
-    private:
-        int bidx;
-    };
-
-    template <typename T, int SRCCN, int DSTCN>
-    void RGB2RGB_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        RGB2RGB<T, SRCCN, DSTCN> cvt(bidx);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        static const RGB2RGB_caller_t RGB2RGB_callers[2][2] =
-        {
-            {RGB2RGB_caller<uchar, 3, 3>, RGB2RGB_caller<uchar, 3, 4>},
-            {RGB2RGB_caller<uchar, 4, 3>, RGB2RGB_caller<uchar, 4, 4>}
-        };
-
-        RGB2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, stream);
-    }
-
-    void RGB2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        static const RGB2RGB_caller_t RGB2RGB_callers[2][2] =
-        {
-            {RGB2RGB_caller<ushort, 3, 3>, RGB2RGB_caller<ushort, 3, 4>},
-            {RGB2RGB_caller<ushort, 4, 3>, RGB2RGB_caller<ushort, 4, 4>}
-        };
-
-        RGB2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, stream);
-    }
-
-    void RGB2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        static const RGB2RGB_caller_t RGB2RGB_callers[2][2] =
-        {
-            {RGB2RGB_caller<float, 3, 3>, RGB2RGB_caller<float, 3, 4>},
-            {RGB2RGB_caller<float, 4, 3>, RGB2RGB_caller<float, 4, 4>}
-        };
-
-        RGB2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, stream);
-    }
-
-/////////// Transforming 16-bit (565 or 555) RGB to/from 24/32-bit (888[8]) RGB //////////
-
-    template <int GREEN_BITS> struct RGB5x52RGBConverter;
-    template <> struct RGB5x52RGBConverter<5>
-    {
-        template <typename D>
-        static __device__ __forceinline__ void cvt(uint src, D& dst, int bidx)
-        {
-            (&dst.x)[bidx] = (uchar)(src << 3);
-            dst.y = (uchar)((src >> 2) & ~7);
-            (&dst.x)[bidx ^ 2] = (uchar)((src >> 7) & ~7);
-            setAlpha(dst, (uchar)(src & 0x8000 ? 255 : 0));
-        }
-    };
-    template <> struct RGB5x52RGBConverter<6>
-    {
-        template <typename D>
-        static __device__ __forceinline__ void cvt(uint src, D& dst, int bidx)
-        {
-            (&dst.x)[bidx] = (uchar)(src << 3);
-            dst.y = (uchar)((src >> 3) & ~3);
-            (&dst.x)[bidx ^ 2] = (uchar)((src >> 8) & ~7);
-            setAlpha(dst, (uchar)(255));
-        }
-    };
-
-    template <int GREEN_BITS, int DSTCN> struct RGB5x52RGB
-    {
-        typedef ushort src_t;
-        typedef typename TypeVec<uchar, DSTCN>::vec_t dst_t;
-
-        explicit RGB5x52RGB(int bidx) : bidx(bidx) {}
-
-        __device__ __forceinline__ dst_t operator()(ushort src) const
-        {
-            dst_t dst;
-            RGB5x52RGBConverter<GREEN_BITS>::cvt((uint)src, dst, bidx);
-            return dst;
-        }
-
-    private:
-        int bidx;
-    };
-
-    template <int GREEN_BITS> struct RGB2RGB5x5Converter;
-    template<> struct RGB2RGB5x5Converter<6>
-    {
-        template <typename T>
-        static __device__ __forceinline__ ushort cvt(const T& src, int bidx)
-        {
-            return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~3) << 3) | (((&src.x)[bidx^2] & ~7) << 8));
-        }
-    };
-    template<> struct RGB2RGB5x5Converter<5>
-    {
-        static __device__ __forceinline__ ushort cvt(const uchar3& src, int bidx)
-        {
-            return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7));
-        }
-        static __device__ __forceinline__ ushort cvt(const uchar4& src, int bidx)
-        {
-            return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7) | (src.w ? 0x8000 : 0));
-        }
-    };
-
-    template<int SRCCN, int GREEN_BITS> struct RGB2RGB5x5
-    {
-        typedef typename TypeVec<uchar, SRCCN>::vec_t src_t;
-        typedef ushort dst_t;
-
-        explicit RGB2RGB5x5(int bidx) : bidx(bidx) {}
-
-        __device__ __forceinline__ ushort operator()(const src_t& src)
-        {
-            return RGB2RGB5x5Converter<GREEN_BITS>::cvt(src, bidx);
-        }
-
-    private:
-        int bidx;
-    };
-
-    template <int GREEN_BITS, int DSTCN>
-    void RGB5x52RGB_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        RGB5x52RGB<GREEN_BITS, DSTCN> cvt(bidx);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB5x52RGB_gpu(const DevMem2D& src, int green_bits, const DevMem2D& dst, int dstcn, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB5x52RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        static const RGB5x52RGB_caller_t RGB5x52RGB_callers[2][2] =
-        {
-            {RGB5x52RGB_caller<5, 3>, RGB5x52RGB_caller<5, 4>},
-            {RGB5x52RGB_caller<6, 3>, RGB5x52RGB_caller<6, 4>}
-        };
-
-        RGB5x52RGB_callers[green_bits - 5][dstcn - 3](src, dst, bidx, stream);
-    }
-
-    template <int SRCCN, int GREEN_BITS>
-    void RGB2RGB5x5_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        RGB2RGB5x5<SRCCN, GREEN_BITS> cvt(bidx);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2RGB5x5_gpu(const DevMem2D& src, int srccn, const DevMem2D& dst, int green_bits, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2RGB5x5_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        static const RGB2RGB5x5_caller_t RGB2RGB5x5_callers[2][2] =
-        {
-            {RGB2RGB5x5_caller<3, 5>, RGB2RGB5x5_caller<3, 6>},
-            {RGB2RGB5x5_caller<4, 5>, RGB2RGB5x5_caller<4, 6>}
-        };
-
-        RGB2RGB5x5_callers[srccn - 3][green_bits - 5](src, dst, bidx, stream);
-    }
-
-///////////////////////////////// Grayscale to Color ////////////////////////////////
-
-    template <int DSTCN, typename T> struct Gray2RGB
-    {
-        typedef T src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        __device__ __forceinline__ dst_t operator()(const T& src) const
-        {
-            dst_t dst;
-
-            dst.z = dst.y = dst.x = src;
-            setAlpha(dst, ColorChannel<T>::max());
-
-            return dst;
-        }
-    };
-
-    template <int GREEN_BITS> struct Gray2RGB5x5Converter;
-    template<> struct Gray2RGB5x5Converter<6>
-    {
-        static __device__ __forceinline__ ushort cvt(uint t)
-        {
-            return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
-        }
-    };
-    template<> struct Gray2RGB5x5Converter<5>
-    {
-        static __device__ __forceinline__ ushort cvt(uint t)
-        {
-            t >>= 3;
-            return (ushort)(t | (t << 5) | (t << 10));
-        }
-    };
-
-    template<int GREEN_BITS> struct Gray2RGB5x5
-    {
-        typedef uchar src_t;
-        typedef ushort dst_t;
-
-        __device__ __forceinline__ ushort operator()(uchar src) const
-        {
-            return Gray2RGB5x5Converter<GREEN_BITS>::cvt((uint)src);
-        }
-    };
-
-    template <typename T, int DSTCN>
-    void Gray2RGB_caller(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream)
-    {
-        Gray2RGB<DSTCN, T> cvt;
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void Gray2RGB_gpu_8u(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream)
-    {
-        typedef void (*Gray2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
-        static const Gray2RGB_caller_t Gray2RGB_callers[] = {Gray2RGB_caller<uchar, 3>, Gray2RGB_caller<uchar, 4>};
-
-        Gray2RGB_callers[dstcn - 3](src, dst, stream);
-    }
-
-    void Gray2RGB_gpu_16u(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream)
-    {
-        typedef void (*Gray2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
-        static const Gray2RGB_caller_t Gray2RGB_callers[] = {Gray2RGB_caller<ushort, 3>, Gray2RGB_caller<ushort, 4>};
-
-        Gray2RGB_callers[dstcn - 3](src, dst, stream);
-    }
-
-    void Gray2RGB_gpu_32f(const DevMem2D& src, const DevMem2D& dst, int dstcn, cudaStream_t stream)
-    {
-        typedef void (*Gray2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
-        static const Gray2RGB_caller_t Gray2RGB_callers[] = {Gray2RGB_caller<float, 3>, Gray2RGB_caller<float, 4>};
-
-        Gray2RGB_callers[dstcn - 3](src, dst, stream);
-    }
-
-    template <int GREEN_BITS>
-    void Gray2RGB5x5_caller(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream)
-    {
-        Gray2RGB5x5<GREEN_BITS> cvt;
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void Gray2RGB5x5_gpu(const DevMem2D& src, const DevMem2D& dst, int green_bits, cudaStream_t stream)
-    {
-        typedef void (*Gray2RGB5x5_caller_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
-        static const Gray2RGB5x5_caller_t Gray2RGB5x5_callers[2] =
-        {
-            Gray2RGB5x5_caller<5>, Gray2RGB5x5_caller<6>
-        };
-
-        Gray2RGB5x5_callers[green_bits - 5](src, dst, stream);
-    }
-
-///////////////////////////////// Color to Grayscale ////////////////////////////////
-
-    #undef R2Y
-    #undef G2Y
-    #undef B2Y
-
-    enum
-    {
-        yuv_shift  = 14,
-        xyz_shift  = 12,
-        R2Y        = 4899,
-        G2Y        = 9617,
-        B2Y        = 1868,
-        BLOCK_SIZE = 256
-    };
-
-    template <int GREEN_BITS> struct RGB5x52GrayConverter;
-    template<> struct RGB5x52GrayConverter<6>
-    {
-        static __device__ __forceinline__ uchar cvt(uint t)
-        {
-            return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
-        }
-    };
-    template<> struct RGB5x52GrayConverter<5>
-    {
-        static __device__ __forceinline__ uchar cvt(uint t)
-        {
-            return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
-        }
-    };
-
-    template<int GREEN_BITS> struct RGB5x52Gray
-    {
-        typedef ushort src_t;
-        typedef uchar dst_t;
-
-        __device__ __forceinline__ uchar operator()(ushort src) const
-        {
-            return RGB5x52GrayConverter<GREEN_BITS>::cvt((uint)src);
-        }
-    };
-
-    template <typename T>
-    __device__ __forceinline__ T RGB2GrayConvert(const T* src, int bidx)
-    {
-        return (T)CV_DESCALE((unsigned)(src[bidx] * B2Y + src[1] * G2Y + src[bidx^2] * R2Y), yuv_shift);
-    }
-     __device__ __forceinline__ float RGB2GrayConvert(const float* src, int bidx)
-    {
-        const float cr = 0.299f;
-        const float cg = 0.587f;
-        const float cb = 0.114f;
-
-        return src[bidx] * cb + src[1] * cg + src[bidx^2] * cr;
-    }
-
-    template <int SRCCN, typename T> struct RGB2Gray
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef T dst_t;
-
-        explicit RGB2Gray(int bidx) : bidx(bidx) {}
-
-        __device__ __forceinline__ T operator()(const src_t& src)
-        {
-            return RGB2GrayConvert(&src.x, bidx);
-        }
-
-    private:
-        int bidx;
-    };
-
-    template <typename T, int SRCCN>
-    void RGB2Gray_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        RGB2Gray<SRCCN, T> cvt(bidx);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2Gray_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2Gray_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        RGB2Gray_caller_t RGB2Gray_callers[] = {RGB2Gray_caller<uchar, 3>, RGB2Gray_caller<uchar, 4>};
-
-        RGB2Gray_callers[srccn - 3](src, dst, bidx, stream);
-    }
-
-    void RGB2Gray_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2Gray_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        RGB2Gray_caller_t RGB2Gray_callers[] = {RGB2Gray_caller<ushort, 3>, RGB2Gray_caller<ushort, 4>};
-
-        RGB2Gray_callers[srccn - 3](src, dst, bidx, stream);
-    }
-
-    void RGB2Gray_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int bidx, cudaStream_t stream)
-    {
-        typedef void (*RGB2Gray_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, cudaStream_t stream);
-        RGB2Gray_caller_t RGB2Gray_callers[] = {RGB2Gray_caller<float, 3>, RGB2Gray_caller<float, 4>};
-
-        RGB2Gray_callers[srccn - 3](src, dst, bidx, stream);
-    }
-
-    template <int GREEN_BITS>
-    void RGB5x52Gray_caller(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream)
-    {
-        RGB5x52Gray<GREEN_BITS> cvt;
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB5x52Gray_gpu(const DevMem2D& src, int green_bits, const DevMem2D& dst, cudaStream_t stream)
-    {
-        typedef void (*RGB5x52Gray_caller_t)(const DevMem2D& src, const DevMem2D& dst, cudaStream_t stream);
-        static const RGB5x52Gray_caller_t RGB5x52Gray_callers[2] =
-        {
-            RGB5x52Gray_caller<5>, RGB5x52Gray_caller<6>
-        };
-
-        RGB5x52Gray_callers[green_bits - 5](src, dst, stream);
-    }
-
-///////////////////////////////////// RGB <-> YCrCb //////////////////////////////////////
-
-    __constant__ int cYCrCbCoeffs_i[5];
-    __constant__ float cYCrCbCoeffs_f[5];
-
-    template <typename T, typename D>
-    __device__ __forceinline__ void RGB2YCrCbConvert(const T* src, D& dst, int bidx)
-    {
-        const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
-
-        const int Y = CV_DESCALE(src[0] * cYCrCbCoeffs_i[0] + src[1] * cYCrCbCoeffs_i[1] + src[2] * cYCrCbCoeffs_i[2], yuv_shift);
-        const int Cr = CV_DESCALE((src[bidx^2] - Y) * cYCrCbCoeffs_i[3] + delta, yuv_shift);
-        const int Cb = CV_DESCALE((src[bidx] - Y) * cYCrCbCoeffs_i[4] + delta, yuv_shift);
-
-        dst.x = saturate_cast<T>(Y);
-        dst.y = saturate_cast<T>(Cr);
-        dst.z = saturate_cast<T>(Cb);
-    }
-    template <typename D>
-    static __device__ __forceinline__ void RGB2YCrCbConvert(const float* src, D& dst, int bidx)
-    {
-        dst.x = src[0] * cYCrCbCoeffs_f[0] + src[1] * cYCrCbCoeffs_f[1] + src[2] * cYCrCbCoeffs_f[2];
-        dst.y = (src[bidx^2] - dst.x) * cYCrCbCoeffs_f[3] + ColorChannel<float>::half();
-        dst.z = (src[bidx] - dst.x) * cYCrCbCoeffs_f[4] + ColorChannel<float>::half();
-    }
-
-    template<typename T> struct RGB2YCrCbBase
-    {
-        typedef int coeff_t;
-
-        explicit RGB2YCrCbBase(const coeff_t coeffs[5])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cYCrCbCoeffs_i, coeffs, 5 * sizeof(int)) );
-        }
-    };
-    template<> struct RGB2YCrCbBase<float>
-    {
-        typedef float coeff_t;
-
-        explicit RGB2YCrCbBase(const coeff_t coeffs[5])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cYCrCbCoeffs_f, coeffs, 5 * sizeof(float)) );
-        }
-    };
-    template <int SRCCN, int DSTCN, typename T> struct RGB2YCrCb : RGB2YCrCbBase<T>
-    {
-        typedef typename RGB2YCrCbBase<T>::coeff_t coeff_t;
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        RGB2YCrCb(int bidx, const coeff_t coeffs[5]) : RGB2YCrCbBase<T>(coeffs), bidx(bidx) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            RGB2YCrCbConvert(&src.x, dst, bidx);
-            return dst;
-        }
-
-    private:
-        int bidx;
-    };
-
-    template <typename T, typename D>
-    __device__ __forceinline__ void YCrCb2RGBConvert(const T& src, D* dst, int bidx)
-    {
-        const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * cYCrCbCoeffs_i[3], yuv_shift);
-        const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * cYCrCbCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * cYCrCbCoeffs_i[1], yuv_shift);
-        const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * cYCrCbCoeffs_i[0], yuv_shift);
-
-        dst[bidx] = saturate_cast<D>(b);
-        dst[1] = saturate_cast<D>(g);
-        dst[bidx^2] = saturate_cast<D>(r);
-    }
-    template <typename T>
-    __device__ __forceinline__ void YCrCb2RGBConvert(const T& src, float* dst, int bidx)
-    {
-        dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * cYCrCbCoeffs_f[3];
-        dst[1] = src.x + (src.z - ColorChannel<float>::half()) * cYCrCbCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * cYCrCbCoeffs_f[1];
-        dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * cYCrCbCoeffs_f[0];
-    }
-
-    template<typename T> struct YCrCb2RGBBase
-    {
-        typedef int coeff_t;
-
-        explicit YCrCb2RGBBase(const coeff_t coeffs[4])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cYCrCbCoeffs_i, coeffs, 4 * sizeof(int)) );
-        }
-    };
-    template<> struct YCrCb2RGBBase<float>
-    {
-        typedef float coeff_t;
-
-        explicit YCrCb2RGBBase(const coeff_t coeffs[4])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cYCrCbCoeffs_f, coeffs, 4 * sizeof(float)) );
-        }
-    };
-    template <int SRCCN, int DSTCN, typename T> struct YCrCb2RGB : YCrCb2RGBBase<T>
-    {
-        typedef typename YCrCb2RGBBase<T>::coeff_t coeff_t;
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        YCrCb2RGB(int bidx, const coeff_t coeffs[4]) : YCrCb2RGBBase<T>(coeffs), bidx(bidx) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-
-            YCrCb2RGBConvert(src, &dst.x, bidx);
-            setAlpha(dst, ColorChannel<T>::max());
-
-            return dst;
-        }
-
-    private:
-        int bidx;
-    };
-
-    template <typename T, int SRCCN, int DSTCN>
-    void RGB2YCrCb_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef typename RGB2YCrCb<SRCCN, DSTCN, T>::coeff_t coeff_t;
-        RGB2YCrCb<SRCCN, DSTCN, T> cvt(bidx, (const coeff_t*)coeffs);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2YCrCb_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2YCrCb_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const RGB2YCrCb_caller_t RGB2YCrCb_callers[2][2] =
-        {
-            {RGB2YCrCb_caller<uchar, 3, 3>, RGB2YCrCb_caller<uchar, 3, 4>},
-            {RGB2YCrCb_caller<uchar, 4, 3>, RGB2YCrCb_caller<uchar, 4, 4>}
-        };
-
-        RGB2YCrCb_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-    void RGB2YCrCb_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2YCrCb_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const RGB2YCrCb_caller_t RGB2YCrCb_callers[2][2] =
-        {
-            {RGB2YCrCb_caller<ushort, 3, 3>, RGB2YCrCb_caller<ushort, 3, 4>},
-            {RGB2YCrCb_caller<ushort, 4, 3>, RGB2YCrCb_caller<ushort, 4, 4>}
-        };
-
-        RGB2YCrCb_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-    void RGB2YCrCb_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2YCrCb_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const RGB2YCrCb_caller_t RGB2YCrCb_callers[2][2] =
-        {
-            {RGB2YCrCb_caller<float, 3, 3>, RGB2YCrCb_caller<float, 3, 4>},
-            {RGB2YCrCb_caller<float, 4, 3>, RGB2YCrCb_caller<float, 4, 4>}
-        };
-
-        RGB2YCrCb_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-    template <typename T, int SRCCN, int DSTCN>
-    void YCrCb2RGB_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef typename YCrCb2RGB<SRCCN, DSTCN, T>::coeff_t coeff_t;
-        YCrCb2RGB<SRCCN, DSTCN, T> cvt(bidx, (const coeff_t*)coeffs);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void YCrCb2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*YCrCb2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const YCrCb2RGB_caller_t YCrCb2RGB_callers[2][2] =
-        {
-            {YCrCb2RGB_caller<uchar, 3, 3>, YCrCb2RGB_caller<uchar, 3, 4>},
-            {YCrCb2RGB_caller<uchar, 4, 3>, YCrCb2RGB_caller<uchar, 4, 4>}
-        };
-
-        YCrCb2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-    void YCrCb2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*YCrCb2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const YCrCb2RGB_caller_t YCrCb2RGB_callers[2][2] =
-        {
-            {YCrCb2RGB_caller<ushort, 3, 3>, YCrCb2RGB_caller<ushort, 3, 4>},
-            {YCrCb2RGB_caller<ushort, 4, 3>, YCrCb2RGB_caller<ushort, 4, 4>}
-        };
-
-        YCrCb2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-    void YCrCb2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*YCrCb2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, const void* coeffs, cudaStream_t stream);
-        static const YCrCb2RGB_caller_t YCrCb2RGB_callers[2][2] =
-        {
-            {YCrCb2RGB_caller<float, 3, 3>, YCrCb2RGB_caller<float, 3, 4>},
-            {YCrCb2RGB_caller<float, 4, 3>, YCrCb2RGB_caller<float, 4, 4>}
-        };
-
-        YCrCb2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, coeffs, stream);
-    }
-
-////////////////////////////////////// RGB <-> XYZ ///////////////////////////////////////
-
-    __constant__ int cXYZ_D65i[9];
-    __constant__ float cXYZ_D65f[9];
-
-    template <typename T, typename D>
-    __device__ __forceinline__ void RGB2XYZConvert(const T* src, D& dst)
-    {
-        dst.x = saturate_cast<T>(CV_DESCALE(src[0] * cXYZ_D65i[0] + src[1] * cXYZ_D65i[1] + src[2] * cXYZ_D65i[2], xyz_shift));
-        dst.y = saturate_cast<T>(CV_DESCALE(src[0] * cXYZ_D65i[3] + src[1] * cXYZ_D65i[4] + src[2] * cXYZ_D65i[5], xyz_shift));
-        dst.z = saturate_cast<T>(CV_DESCALE(src[0] * cXYZ_D65i[6] + src[1] * cXYZ_D65i[7] + src[2] * cXYZ_D65i[8], xyz_shift));
-    }
-    template <typename D>
-    __device__ __forceinline__ void RGB2XYZConvert(const float* src, D& dst)
-    {
-        dst.x = src[0] * cXYZ_D65f[0] + src[1] * cXYZ_D65f[1] + src[2] * cXYZ_D65f[2];
-        dst.y = src[0] * cXYZ_D65f[3] + src[1] * cXYZ_D65f[4] + src[2] * cXYZ_D65f[5];
-        dst.z = src[0] * cXYZ_D65f[6] + src[1] * cXYZ_D65f[7] + src[2] * cXYZ_D65f[8];
-    }
-
-    template <typename T> struct RGB2XYZBase
-    {
-        typedef int coeff_t;
-
-        explicit RGB2XYZBase(const coeff_t coeffs[9])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cXYZ_D65i, coeffs, 9 * sizeof(int)) );
-        }
-    };
-    template <> struct RGB2XYZBase<float>
-    {
-        typedef float coeff_t;
-
-        explicit RGB2XYZBase(const coeff_t coeffs[9])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cXYZ_D65f, coeffs, 9 * sizeof(float)) );
-        }
-    };
-    template <int SRCCN, int DSTCN, typename T> struct RGB2XYZ : RGB2XYZBase<T>
-    {
-        typedef typename RGB2XYZBase<T>::coeff_t coeff_t;
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        explicit RGB2XYZ(const coeff_t coeffs[9]) : RGB2XYZBase<T>(coeffs) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            RGB2XYZConvert(&src.x, dst);
-            return dst;
-        }
-    };
-
-    template <typename T, typename D>
-    __device__ __forceinline__ void XYZ2RGBConvert(const T& src, D* dst)
-    {
-        dst[0] = saturate_cast<D>(CV_DESCALE(src.x * cXYZ_D65i[0] + src.y * cXYZ_D65i[1] + src.z * cXYZ_D65i[2], xyz_shift));
-            dst[1] = saturate_cast<D>(CV_DESCALE(src.x * cXYZ_D65i[3] + src.y * cXYZ_D65i[4] + src.z * cXYZ_D65i[5], xyz_shift));
-            dst[2] = saturate_cast<D>(CV_DESCALE(src.x * cXYZ_D65i[6] + src.y * cXYZ_D65i[7] + src.z * cXYZ_D65i[8], xyz_shift));
-    }
-    template <typename T>
-    __device__ __forceinline__ void XYZ2RGBConvert(const T& src, float* dst)
-    {
-        dst[0] = src.x * cXYZ_D65f[0] + src.y * cXYZ_D65f[1] + src.z * cXYZ_D65f[2];
-            dst[1] = src.x * cXYZ_D65f[3] + src.y * cXYZ_D65f[4] + src.z * cXYZ_D65f[5];
-            dst[2] = src.x * cXYZ_D65f[6] + src.y * cXYZ_D65f[7] + src.z * cXYZ_D65f[8];
-    }
-
-    template <typename T> struct XYZ2RGBBase
-    {
-        typedef int coeff_t;
-
-        explicit XYZ2RGBBase(const coeff_t coeffs[9])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cXYZ_D65i, coeffs, 9 * sizeof(int)) );
-        }
-    };
-    template <> struct XYZ2RGBBase<float>
-    {
-        typedef float coeff_t;
-
-        explicit XYZ2RGBBase(const coeff_t coeffs[9])
-        {
-            cudaSafeCall( cudaMemcpyToSymbol(cXYZ_D65f, coeffs, 9 * sizeof(float)) );
-        }
-    };
-    template <int SRCCN, int DSTCN, typename T> struct XYZ2RGB : XYZ2RGBBase<T>
-    {
-        typedef typename RGB2XYZBase<T>::coeff_t coeff_t;
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        explicit XYZ2RGB(const coeff_t coeffs[9]) : XYZ2RGBBase<T>(coeffs) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            XYZ2RGBConvert(src, &dst.x);
-            setAlpha(dst, ColorChannel<T>::max());
-            return dst;
-        }
-    };
-
-    template <typename T, int SRCCN, int DSTCN>
-    void RGB2XYZ_caller(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream)
-    {
-        typedef typename RGB2XYZ<SRCCN, DSTCN, T>::coeff_t coeff_t;
-        RGB2XYZ<SRCCN, DSTCN, T> cvt((const coeff_t*)coeffs);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2XYZ_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2XYZ_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const RGB2XYZ_caller_t RGB2XYZ_callers[2][2] =
-        {
-            {RGB2XYZ_caller<uchar, 3, 3>, RGB2XYZ_caller<uchar, 3, 4>},
-            {RGB2XYZ_caller<uchar, 4, 3>, RGB2XYZ_caller<uchar, 4, 4>}
-        };
-
-        RGB2XYZ_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-    void RGB2XYZ_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2XYZ_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const RGB2XYZ_caller_t RGB2XYZ_callers[2][2] =
-        {
-            {RGB2XYZ_caller<ushort, 3, 3>, RGB2XYZ_caller<ushort, 3, 4>},
-            {RGB2XYZ_caller<ushort, 4, 3>, RGB2XYZ_caller<ushort, 4, 4>}
-        };
-
-        RGB2XYZ_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-    void RGB2XYZ_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*RGB2XYZ_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const RGB2XYZ_caller_t RGB2XYZ_callers[2][2] =
-        {
-            {RGB2XYZ_caller<float, 3, 3>, RGB2XYZ_caller<float, 3, 4>},
-            {RGB2XYZ_caller<float, 4, 3>, RGB2XYZ_caller<float, 4, 4>}
-        };
-
-        RGB2XYZ_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-    template <typename T, int SRCCN, int DSTCN>
-    void XYZ2RGB_caller(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream)
-    {
-        typedef typename XYZ2RGB<SRCCN, DSTCN, T>::coeff_t coeff_t;
-        XYZ2RGB<SRCCN, DSTCN, T> cvt((const coeff_t*)coeffs);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void XYZ2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*XYZ2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const XYZ2RGB_caller_t XYZ2RGB_callers[2][2] =
-        {
-            {XYZ2RGB_caller<uchar, 3, 3>, XYZ2RGB_caller<uchar, 3, 4>},
-            {XYZ2RGB_caller<uchar, 4, 3>, XYZ2RGB_caller<uchar, 4, 4>}
-        };
-
-        XYZ2RGB_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-    void XYZ2RGB_gpu_16u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*XYZ2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const XYZ2RGB_caller_t XYZ2RGB_callers[2][2] =
-        {
-            {XYZ2RGB_caller<ushort, 3, 3>, XYZ2RGB_caller<ushort, 3, 4>},
-            {XYZ2RGB_caller<ushort, 4, 3>, XYZ2RGB_caller<ushort, 4, 4>}
-        };
-
-        XYZ2RGB_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-    void XYZ2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, const void* coeffs, cudaStream_t stream)
-    {
-        typedef void (*XYZ2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, const void* coeffs, cudaStream_t stream);
-        static const XYZ2RGB_caller_t XYZ2RGB_callers[2][2] =
-        {
-            {XYZ2RGB_caller<float, 3, 3>, XYZ2RGB_caller<float, 3, 4>},
-            {XYZ2RGB_caller<float, 4, 3>, XYZ2RGB_caller<float, 4, 4>}
-        };
-
-        XYZ2RGB_callers[srccn-3][dstcn-3](src, dst, coeffs, stream);
-    }
-
-////////////////////////////////////// RGB <-> HSV ///////////////////////////////////////
-
-    __constant__ int cHsvDivTable   [256] = {0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211, 130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632, 65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412, 43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693, 32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782, 26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223, 21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991, 18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579, 16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711, 14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221, 13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006, 11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995, 10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141, 10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410, 9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777, 8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224, 8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737, 7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304, 7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917, 6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569, 6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254, 6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968, 5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708, 5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468, 5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249, 5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046, 5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858, 4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684, 4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522, 4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370, 4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229, 4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096};
-    __constant__ int cHsvDivTable180[256] = {0, 122880, 61440, 40960, 30720, 24576, 20480, 17554, 15360, 13653, 12288, 11171, 10240, 9452, 8777, 8192, 7680, 7228, 6827, 6467, 6144, 5851, 5585, 5343, 5120, 4915, 4726, 4551, 4389, 4237, 4096, 3964, 3840, 3724, 3614, 3511, 3413, 3321, 3234, 3151, 3072, 2997, 2926, 2858, 2793, 2731, 2671, 2614, 2560, 2508, 2458, 2409, 2363, 2318, 2276, 2234, 2194, 2156, 2119, 2083, 2048, 2014, 1982, 1950, 1920, 1890, 1862, 1834, 1807, 1781, 1755, 1731, 1707, 1683, 1661, 1638, 1617, 1596, 1575, 1555, 1536, 1517, 1499, 1480, 1463, 1446, 1429, 1412, 1396, 1381, 1365, 1350, 1336, 1321, 1307, 1293, 1280, 1267, 1254, 1241, 1229, 1217, 1205, 1193, 1182, 1170, 1159, 1148, 1138, 1127, 1117, 1107, 1097, 1087, 1078, 1069, 1059, 1050, 1041, 1033, 1024, 1016, 1007, 999, 991, 983, 975, 968, 960, 953, 945, 938, 931, 924, 917, 910, 904, 897, 890, 884, 878, 871, 865, 859, 853, 847, 842, 836, 830, 825, 819, 814, 808, 803, 798, 793, 788, 783, 778, 773, 768, 763, 759, 754, 749, 745, 740, 736, 731, 727, 723, 719, 714, 710, 706, 702, 698, 694, 690, 686, 683, 679, 675, 671, 668, 664, 661, 657, 654, 650, 647, 643, 640, 637, 633, 630, 627, 624, 621, 617, 614, 611, 608, 605, 602, 599, 597, 594, 591, 588, 585, 582, 580, 577, 574, 572, 569, 566, 564, 561, 559, 556, 554, 551, 549, 546, 544, 541, 539, 537, 534, 532, 530, 527, 525, 523, 521, 518, 516, 514, 512, 510, 508, 506, 504, 502, 500, 497, 495, 493, 492, 490, 488, 486, 484, 482};
-    __constant__ int cHsvDivTable256[256] = {0, 174763, 87381, 58254, 43691, 34953, 29127, 24966, 21845, 19418, 17476, 15888, 14564, 13443, 12483, 11651, 10923, 10280, 9709, 9198, 8738, 8322, 7944, 7598, 7282, 6991, 6722, 6473, 6242, 6026, 5825, 5638, 5461, 5296, 5140, 4993, 4855, 4723, 4599, 4481, 4369, 4263, 4161, 4064, 3972, 3884, 3799, 3718, 3641, 3567, 3495, 3427, 3361, 3297, 3236, 3178, 3121, 3066, 3013, 2962, 2913, 2865, 2819, 2774, 2731, 2689, 2648, 2608, 2570, 2533, 2497, 2461, 2427, 2394, 2362, 2330, 2300, 2270, 2241, 2212, 2185, 2158, 2131, 2106, 2081, 2056, 2032, 2009, 1986, 1964, 1942, 1920, 1900, 1879, 1859, 1840, 1820, 1802, 1783, 1765, 1748, 1730, 1713, 1697, 1680, 1664, 1649, 1633, 1618, 1603, 1589, 1574, 1560, 1547, 1533, 1520, 1507, 1494, 1481, 1469, 1456, 1444, 1432, 1421, 1409, 1398, 1387, 1376, 1365, 1355, 1344, 1334, 1324, 1314, 1304, 1295, 1285, 1276, 1266, 1257, 1248, 1239, 1231, 1222, 1214, 1205, 1197, 1189, 1181, 1173, 1165, 1157, 1150, 1142, 1135, 1128, 1120, 1113, 1106, 1099, 1092, 1085, 1079, 1072, 1066, 1059, 1053, 1046, 1040, 1034, 1028, 1022, 1016, 1010, 1004, 999, 993, 987, 982, 976, 971, 966, 960, 955, 950, 945, 940, 935, 930, 925, 920, 915, 910, 906, 901, 896, 892, 887, 883, 878, 874, 869, 865, 861, 857, 853, 848, 844, 840, 836, 832, 828, 824, 820, 817, 813, 809, 805, 802, 798, 794, 791, 787, 784, 780, 777, 773, 770, 767, 763, 760, 757, 753, 750, 747, 744, 741, 737, 734, 731, 728, 725, 722, 719, 716, 713, 710, 708, 705, 702, 699, 696, 694, 691, 688, 685};
-
-    template <typename D> __device__ void RGB2HSVConvert(const uchar* src, D& dst, int bidx, int hr)
-    {
-        const int hsv_shift = 12;
-        const int* hdiv_table = hr == 180 ? cHsvDivTable180 : cHsvDivTable256;
-
-        int b = src[bidx], g = src[1], r = src[bidx^2];
-        int h, s, v = b;
-        int vmin = b, diff;
-        int vr, vg;
-
-        v = max(v, g);
-        v = max(v, r);
-        vmin = min(vmin, g);
-        vmin = min(vmin, r);
-
-        diff = v - vmin;
-        vr = v == r ? -1 : 0;
-        vg = v == g ? -1 : 0;
-
-        s = (diff * cHsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
-        h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
-        h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
-        h += h < 0 ? hr : 0;
-
-        dst.x = saturate_cast<uchar>(h);
-        dst.y = (uchar)s;
-        dst.z = (uchar)v;
-    }
-    template<typename D> __device__ void RGB2HSVConvert(const float* src, D& dst, int bidx, int hr)
-    {
-        const float hscale = hr * (1.f / 360.f);
-
-        float b = src[bidx], g = src[1], r = src[bidx^2];
-        float h, s, v;
-
-        float vmin, diff;
-
-        v = vmin = r;
-        v = fmax(v, g);
-        v = fmax(v, b);
-        vmin = fmin(vmin, g);
-        vmin = fmin(vmin, b);
-
-        diff = v - vmin;
-        s = diff / (float)(fabs(v) + numeric_limits_gpu<float>::epsilon());
-        diff = (float)(60. / (diff + numeric_limits_gpu<float>::epsilon()));
-
-        if (v == r)
-            h = (g - b) * diff;
-        else if (v == g)
-            h = (b - r) * diff + 120.f;
-        else
-            h = (r - g) * diff + 240.f;
-
-        if (h < 0) h += 360.f;
-
-        dst.x = h * hscale;
-        dst.y = s;
-        dst.z = v;
-    }
-
-    template <int SRCCN, int DSTCN, typename T> struct RGB2HSV
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        RGB2HSV(int bidx, int hr) : bidx(bidx), hr(hr) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            RGB2HSVConvert(&src.x, dst, bidx, hr);
-            return dst;
-        }
-
-    private:
-        int bidx;
-        int hr;
-    };
-
-    __constant__ int cHsvSectorData[6][3] =
-    {
-        {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}
-    };
-
-    template <typename T> __device__ void HSV2RGBConvert(const T& src, float* dst, int bidx, int hr)
-    {
-        const float hscale = 6.f / hr;
-
-        float h = src.x, s = src.y, v = src.z;
-        float b, g, r;
-
-        if( s == 0 )
-            b = g = r = v;
-        else
-        {
-            float tab[4];
-            int sector;
-            h *= hscale;
-            if( h < 0 )
-                do h += 6; while( h < 0 );
-            else if( h >= 6 )
-                do h -= 6; while( h >= 6 );
-            sector = __float2int_rd(h);
-            h -= sector;
-
-            tab[0] = v;
-            tab[1] = v*(1.f - s);
-            tab[2] = v*(1.f - s*h);
-            tab[3] = v*(1.f - s*(1.f - h));
-
-            b = tab[cHsvSectorData[sector][0]];
-            g = tab[cHsvSectorData[sector][1]];
-            r = tab[cHsvSectorData[sector][2]];
-        }
-
-        dst[bidx] = b;
-        dst[1] = g;
-        dst[bidx^2] = r;
-    }
-    template <typename T> __device__ void HSV2RGBConvert(const T& src, uchar* dst, int bidx, int hr)
-    {
-        float3 buf;
-
-        buf.x = src.x;
-        buf.y = src.y * (1.f/255.f);
-        buf.z = src.z * (1.f/255.f);
-
-        HSV2RGBConvert(buf, &buf.x, bidx, hr);
-
-        dst[0] = saturate_cast<uchar>(buf.x * 255.f);
-        dst[1] = saturate_cast<uchar>(buf.y * 255.f);
-        dst[2] = saturate_cast<uchar>(buf.z * 255.f);
-    }
-
-    template <int SRCCN, int DSTCN, typename T> struct HSV2RGB
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        HSV2RGB(int bidx, int hr) : bidx(bidx), hr(hr) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            HSV2RGBConvert(src, &dst.x, bidx, hr);
-            setAlpha(dst, ColorChannel<T>::max());
-            return dst;
-        }
-
-    private:
-        int bidx;
-        int hr;
-    };
-
-    template <typename T, int SRCCN, int DSTCN>
-    void RGB2HSV_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream)
-    {
-        RGB2HSV<SRCCN, DSTCN, T> cvt(bidx, hrange);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2HSV_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*RGB2HSV_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const RGB2HSV_caller_t RGB2HSV_callers[2][2] =
-        {
-            {RGB2HSV_caller<uchar, 3, 3>, RGB2HSV_caller<uchar, 3, 4>},
-            {RGB2HSV_caller<uchar, 4, 3>, RGB2HSV_caller<uchar, 4, 4>}
-        };
-
-        RGB2HSV_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-    void RGB2HSV_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*RGB2HSV_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const RGB2HSV_caller_t RGB2HSV_callers[2][2] =
-        {
-            {RGB2HSV_caller<float, 3, 3>, RGB2HSV_caller<float, 3, 4>},
-            {RGB2HSV_caller<float, 4, 3>, RGB2HSV_caller<float, 4, 4>}
-        };
-
-        RGB2HSV_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-    template <typename T, int SRCCN, int DSTCN>
-    void HSV2RGB_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream)
-    {
-        HSV2RGB<SRCCN, DSTCN, T> cvt(bidx, hrange);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void HSV2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*HSV2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const HSV2RGB_caller_t HSV2RGB_callers[2][2] =
-        {
-            {HSV2RGB_caller<uchar, 3, 3>, HSV2RGB_caller<uchar, 3, 4>},
-            {HSV2RGB_caller<uchar, 4, 3>, HSV2RGB_caller<uchar, 4, 4>}
-        };
-
-        HSV2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-    void HSV2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*HSV2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const HSV2RGB_caller_t HSV2RGB_callers[2][2] =
-        {
-            {HSV2RGB_caller<float, 3, 3>, HSV2RGB_caller<float, 3, 4>},
-            {HSV2RGB_caller<float, 4, 3>, HSV2RGB_caller<float, 4, 4>}
-        };
-
-        HSV2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-/////////////////////////////////////// RGB <-> HLS ////////////////////////////////////////
-
-    template <typename D> __device__ void RGB2HLSConvert(const float* src, D& dst, int bidx, int hr)
-    {
-        const float hscale = hr * (1.f / 360.f);
-
-        float b = src[bidx], g = src[1], r = src[bidx^2];
-        float h = 0.f, s = 0.f, l;
-        float vmin, vmax, diff;
-
-        vmax = vmin = r;
-        vmax = fmax(vmax, g);
-        vmax = fmax(vmax, b);
-        vmin = fmin(vmin, g);
-        vmin = fmin(vmin, b);
-
-        diff = vmax - vmin;
-        l = (vmax + vmin) * 0.5f;
-
-        if (diff > numeric_limits_gpu<float>::epsilon())
-        {
-            s = l < 0.5f ? diff / (vmax + vmin) : diff / (2.0f - vmax - vmin);
-            diff = 60.f / diff;
-
-            if (vmax == r)
-                h = (g - b)*diff;
-            else if (vmax == g)
-                h = (b - r)*diff + 120.f;
-            else
-                h = (r - g)*diff + 240.f;
-
-            if (h < 0.f) h += 360.f;
-        }
-
-        dst.x = h * hscale;
-        dst.y = l;
-        dst.z = s;
-    }
-    template <typename D> __device__ void RGB2HLSConvert(const uchar* src, D& dst, int bidx, int hr)
-    {
-        float3 buf;
-
-        buf.x = src[0]*(1.f/255.f);
-        buf.y = src[1]*(1.f/255.f);
-        buf.z = src[2]*(1.f/255.f);
-
-        RGB2HLSConvert(&buf.x, buf, bidx, hr);
-
-        dst.x = saturate_cast<uchar>(buf.x);
-        dst.y = saturate_cast<uchar>(buf.y*255.f);
-        dst.z = saturate_cast<uchar>(buf.z*255.f);
-    }
-
-    template <int SRCCN, int DSTCN, typename T> struct RGB2HLS
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        RGB2HLS(int bidx, int hr) : bidx(bidx), hr(hr) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            RGB2HLSConvert(&src.x, dst, bidx, hr);
-            return dst;
-        }
-
-    private:
-        int bidx;
-        int hr;
-    };
-
-    __constant__ int cHlsSectorData[6][3] =
-    {
-        {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}
-    };
-
-    template <typename T> __device__ void HLS2RGBConvert(const T& src, float* dst, int bidx, int hr)
-    {
-        const float hscale = 6.0f / hr;
-
-        float h = src.x, l = src.y, s = src.z;
-        float b, g, r;
-
-        if (s == 0)
-            b = g = r = l;
-        else
-        {
-            float tab[4];
-            int sector;
-
-            float p2 = l <= 0.5f ? l * (1 + s) : l + s - l * s;
-            float p1 = 2 * l - p2;
-
-            h *= hscale;
-
-            if( h < 0 )
-                do h += 6; while( h < 0 );
-            else if( h >= 6 )
-                do h -= 6; while( h >= 6 );
-
-            sector = __float2int_rd(h);
-            h -= sector;
-
-            tab[0] = p2;
-            tab[1] = p1;
-            tab[2] = p1 + (p2 - p1) * (1 - h);
-            tab[3] = p1 + (p2 - p1) * h;
-
-            b = tab[cHlsSectorData[sector][0]];
-            g = tab[cHlsSectorData[sector][1]];
-            r = tab[cHlsSectorData[sector][2]];
-        }
-
-        dst[bidx] = b;
-        dst[1] = g;
-        dst[bidx^2] = r;
-    }
-    template <typename T> __device__ void HLS2RGBConvert(const T& src, uchar* dst, int bidx, int hr)
-    {
-        float3 buf;
-
-        buf.x = src.x;
-        buf.y = src.y*(1.f/255.f);
-        buf.z = src.z*(1.f/255.f);
-
-        HLS2RGBConvert(buf, &buf.x, bidx, hr);
-
-        dst[0] = saturate_cast<uchar>(buf.x*255.f);
-        dst[1] = saturate_cast<uchar>(buf.y*255.f);
-        dst[2] = saturate_cast<uchar>(buf.z*255.f);
-    }
-
-    template <int SRCCN, int DSTCN, typename T> struct HLS2RGB
-    {
-        typedef typename TypeVec<T, SRCCN>::vec_t src_t;
-        typedef typename TypeVec<T, DSTCN>::vec_t dst_t;
-
-        HLS2RGB(int bidx, int hr) : bidx(bidx), hr(hr) {}
-
-        __device__ __forceinline__ dst_t operator()(const src_t& src) const
-        {
-            dst_t dst;
-            HLS2RGBConvert(src, &dst.x, bidx, hr);
-            setAlpha(dst, ColorChannel<T>::max());
-            return dst;
-        }
-
-    private:
-        int bidx;
-        int hr;
-    };
-
-    template <typename T, int SRCCN, int DSTCN>
-    void RGB2HLS_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream)
-    {
-        RGB2HLS<SRCCN, DSTCN, T> cvt(bidx, hrange);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void RGB2HLS_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*RGB2HLS_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const RGB2HLS_caller_t RGB2HLS_callers[2][2] =
-        {
-            {RGB2HLS_caller<uchar, 3, 3>, RGB2HLS_caller<uchar, 3, 4>},
-            {RGB2HLS_caller<uchar, 4, 3>, RGB2HLS_caller<uchar, 4, 4>}
-        };
-
-        RGB2HLS_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-    void RGB2HLS_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*RGB2HLS_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const RGB2HLS_caller_t RGB2HLS_callers[2][2] =
-        {
-            {RGB2HLS_caller<float, 3, 3>, RGB2HLS_caller<float, 3, 4>},
-            {RGB2HLS_caller<float, 4, 3>, RGB2HLS_caller<float, 4, 4>}
-        };
-
-        RGB2HLS_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-
-    template <typename T, int SRCCN, int DSTCN>
-    void HLS2RGB_caller(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream)
-    {
-        HLS2RGB<SRCCN, DSTCN, T> cvt(bidx, hrange);
-        callConvert(src, dst, cvt, stream);
-    }
-
-    void HLS2RGB_gpu_8u(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*HLS2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const HLS2RGB_caller_t HLS2RGB_callers[2][2] =
-        {
-            {HLS2RGB_caller<uchar, 3, 3>, HLS2RGB_caller<uchar, 3, 4>},
-            {HLS2RGB_caller<uchar, 4, 3>, HLS2RGB_caller<uchar, 4, 4>}
-        };
-
-        HLS2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
-
-    void HLS2RGB_gpu_32f(const DevMem2D& src, int srccn, const DevMem2D& dst, int dstcn, int bidx, int hrange, cudaStream_t stream)
-    {
-        typedef void (*HLS2RGB_caller_t)(const DevMem2D& src, const DevMem2D& dst, int bidx, int hrange, cudaStream_t stream);
-        static const HLS2RGB_caller_t HLS2RGB_callers[2][2] =
-        {
-            {HLS2RGB_caller<float, 3, 3>, HLS2RGB_caller<float, 3, 4>},
-            {HLS2RGB_caller<float, 4, 3>, HLS2RGB_caller<float, 4, 4>}
-        };
-
-        HLS2RGB_callers[srccn-3][dstcn-3](src, dst, bidx, hrange, stream);
-    }
+    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
+
+    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
+
+    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
+        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv4)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgra)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls4)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls4)
+
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgb)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgba)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgra)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgr)
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgra)
+
+    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
+    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
+    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
+    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
 }}}
diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index de7e865e08..0626d8938a 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -40,8 +40,10 @@
 //
 //M*/
 
-#include "opencv2/gpu/device/vecmath.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "internal_shared.hpp"
 
@@ -54,10 +56,9 @@ namespace cv { namespace gpu { namespace mathfunc
     //////////////////////////////////////////////////////////////////////////////////////
     // Compare
 
-    template <typename T1, typename T2>
-    struct NotEqual
+    template <typename T1, typename T2> struct NotEqual : binary_function<T1, T2, uchar>
     {
-        __device__ __forceinline__ uchar operator()(const T1& src1, const T2& src2)
+        __device__ __forceinline__ uchar operator()(const T1& src1, const T2& src2) const
         {
             return static_cast<uchar>(static_cast<int>(src1 != src2) * 255);
         }
@@ -169,10 +170,10 @@ namespace cv { namespace gpu { namespace mathfunc
     }
 
 
-    void bitwiseNotCaller(int rows, int cols, int elem_size1, int cn, 
+    void bitwiseNotCaller(int rows, int cols, size_t elem_size1, int cn, 
                           const PtrStep src, PtrStep dst, cudaStream_t stream)
     {
-        bitwiseUnOp<UN_OP_NOT>(rows, cols * elem_size1 * cn, src, dst, stream);
+        bitwiseUnOp<UN_OP_NOT>(rows, static_cast<int>(cols * elem_size1 * cn), src, dst, stream);
     }
 
 
@@ -294,10 +295,10 @@ namespace cv { namespace gpu { namespace mathfunc
     }
 
 
-    void bitwiseOrCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, 
+    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, 
                          const PtrStep src2, PtrStep dst, cudaStream_t stream)
     {
-        bitwiseBinOp<BIN_OP_OR>(rows, cols * elem_size1 * cn, src1, src2, dst, stream);
+        bitwiseBinOp<BIN_OP_OR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
     }
 
 
@@ -313,10 +314,10 @@ namespace cv { namespace gpu { namespace mathfunc
     template void bitwiseMaskOrCaller<uint>(int, int, int, const PtrStep, const PtrStep, const PtrStep, PtrStep, cudaStream_t);
 
 
-    void bitwiseAndCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, 
+    void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, 
                           const PtrStep src2, PtrStep dst, cudaStream_t stream)
     {
-        bitwiseBinOp<BIN_OP_AND>(rows, cols * elem_size1 * cn, src1, src2, dst, stream);
+        bitwiseBinOp<BIN_OP_AND>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
     }
 
 
@@ -332,10 +333,10 @@ namespace cv { namespace gpu { namespace mathfunc
     template void bitwiseMaskAndCaller<uint>(int, int, int, const PtrStep, const PtrStep, const PtrStep, PtrStep, cudaStream_t);
 
 
-    void bitwiseXorCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, 
+    void bitwiseXorCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, 
                           const PtrStep src2, PtrStep dst, cudaStream_t stream)
     {
-        bitwiseBinOp<BIN_OP_XOR>(rows, cols * elem_size1 * cn, src1, src2, dst, stream);
+        bitwiseBinOp<BIN_OP_XOR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
     }
 
 
@@ -353,114 +354,11 @@ namespace cv { namespace gpu { namespace mathfunc
 
     //////////////////////////////////////////////////////////////////////////
     // min/max
-
-    struct MinOp
-    {        
-        template <typename T>
-        __device__ __forceinline__ T operator()(T a, T b)
-        {
-            return min(a, b);
-        }
-        __device__ __forceinline__ float operator()(float a, float b)
-        {
-            return fmin(a, b);
-        }
-        __device__ __forceinline__ double operator()(double a, double b)
-        {
-            return fmin(a, b);
-        }
-    };
-
-    struct MaxOp
-    {        
-        template <typename T>
-        __device__ __forceinline__ T operator()(T a, T b)
-        {
-            return max(a, b);
-        }
-        __device__ __forceinline__ float operator()(float a, float b)
-        {
-            return fmax(a, b);
-        }
-        __device__ __forceinline__ double operator()(double a, double b)
-        {
-            return fmax(a, b);
-        }
-    };
-    
-    template <typename T> struct ScalarMinOp
-    {
-        T s;
-
-        explicit ScalarMinOp(T s_) : s(s_) {}
-
-        __device__ __forceinline__ T operator()(T a)
-        {
-            return min(a, s);
-        }
-    };
-    template <> struct ScalarMinOp<float>
-    {
-        float s;
-
-        explicit ScalarMinOp(float s_) : s(s_) {}
-
-        __device__ __forceinline__ float operator()(float a)
-        {
-            return fmin(a, s);
-        }
-    };
-    template <> struct ScalarMinOp<double>
-    {
-        double s;
-
-        explicit ScalarMinOp(double s_) : s(s_) {}
-
-        __device__ __forceinline__ double operator()(double a)
-        {
-            return fmin(a, s);
-        }
-    };
-    
-    template <typename T> struct ScalarMaxOp
-    {
-        T s;
-
-        explicit ScalarMaxOp(T s_) : s(s_) {}
-
-        __device__ __forceinline__ T operator()(T a)
-        {
-            return max(a, s);
-        }
-    };
-    template <> struct ScalarMaxOp<float>
-    {
-        float s;
-
-        explicit ScalarMaxOp(float s_) : s(s_) {}
-
-        __device__ __forceinline__ float operator()(float a)
-        {
-            return fmax(a, s);
-        }
-    };
-    template <> struct ScalarMaxOp<double>
-    {
-        double s;
-
-        explicit ScalarMaxOp(double s_) : s(s_) {}
-
-        __device__ __forceinline__ double operator()(double a)
-        {
-            return fmax(a, s);
-        }
-    };
     
     template <typename T>
     void min_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
     {
-        MinOp op;
-        transform(src1, src2, dst, op, stream);    
+        transform(src1, src2, dst, minimum<T>(), stream);    
     }
 
     template void min_gpu<uchar >(const DevMem2D& src1, const DevMem2D& src2, const DevMem2D& dst, cudaStream_t stream);
@@ -474,8 +372,7 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void max_gpu(const DevMem2D_<T>& src1, const DevMem2D_<T>& src2, const DevMem2D_<T>& dst, cudaStream_t stream)
     {
-        MaxOp op;
-        transform(src1, src2, dst, op, stream);    
+        transform(src1, src2, dst, maximum<T>(), stream);    
     }
     
     template void max_gpu<uchar >(const DevMem2D& src1, const DevMem2D& src2, const DevMem2D& dst, cudaStream_t stream);
@@ -489,8 +386,7 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void min_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
     {
-        ScalarMinOp<T> op(src2);
-        transform(src1, dst, op, stream);    
+        transform(src1, dst, device::bind2nd(minimum<T>(), src2), stream);    
     }
 
     template void min_gpu<uchar >(const DevMem2D& src1, uchar src2, const DevMem2D& dst, cudaStream_t stream);
@@ -500,12 +396,11 @@ namespace cv { namespace gpu { namespace mathfunc
     template void min_gpu<int   >(const DevMem2D_<int>& src1, int src2, const DevMem2D_<int>& dst, cudaStream_t stream);
     template void min_gpu<float >(const DevMem2D_<float>& src1, float src2, const DevMem2D_<float>& dst, cudaStream_t stream);
     template void min_gpu<double>(const DevMem2D_<double>& src1, double src2, const DevMem2D_<double>& dst, cudaStream_t stream);
-    
+
     template <typename T>
     void max_gpu(const DevMem2D_<T>& src1, T src2, const DevMem2D_<T>& dst, cudaStream_t stream)
     {
-        ScalarMaxOp<T> op(src2);
-        transform(src1, dst, op, stream);    
+        transform(src1, dst, device::bind2nd(maximum<T>(), src2), stream);    
     }
 
     template void max_gpu<uchar >(const DevMem2D& src1, uchar src2, const DevMem2D& dst, cudaStream_t stream);
@@ -518,100 +413,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
     
     //////////////////////////////////////////////////////////////////////////
-    // threshold
-
-    template <typename T> struct ThreshBinary
-    {
-        ThreshBinary(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
-
-        __device__ __forceinline__ T operator()(const T& src) const
-        {
-            return src > thresh ? maxVal : 0;
-        }
-
-    private:
-        T thresh;
-        T maxVal;
-    };
-
-    template <typename T> struct ThreshBinaryInv
-    {
-        ThreshBinaryInv(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
-
-        __device__ __forceinline__ T operator()(const T& src) const
-        {
-            return src > thresh ? 0 : maxVal;
-        }
-
-    private:
-        T thresh;
-        T maxVal;
-    };
-
-    template <typename T> struct ThreshTrunc
-    {
-        ThreshTrunc(T thresh_, T) : thresh(thresh_) {}
-
-        __device__ __forceinline__ T operator()(const T& src) const
-        {
-            return min(src, thresh);
-        }
-
-    private:
-        T thresh;
-    };
-    template <> struct  ThreshTrunc<float>
-    {
-        ThreshTrunc(float thresh_, float) : thresh(thresh_) {}
-
-        __device__ __forceinline__ float operator()(const float& src) const
-        {
-            return fmin(src, thresh);
-        }
-
-    private:
-        float thresh;
-    };
-    template <> struct  ThreshTrunc<double>
-    {
-        ThreshTrunc(double thresh_, double) : thresh(thresh_) {}
-
-        __device__ __forceinline__ double operator()(const double& src) const
-        {
-            return fmin(src, thresh);
-        }
-
-    private:
-        double thresh;
-    };
-
-    template <typename T> struct ThreshToZero
-    {
-    public:
-        ThreshToZero(T thresh_, T) : thresh(thresh_) {}
-
-        __device__ __forceinline__ T operator()(const T& src) const
-        {
-            return src > thresh ? src : 0;
-        }
-
-    private:
-        T thresh;
-    };
-
-    template <typename T> struct ThreshToZeroInv
-    {
-    public:
-        ThreshToZeroInv(T thresh_, T) : thresh(thresh_) {}
-
-        __device__ __forceinline__ T operator()(const T& src) const
-        {
-            return src > thresh ? 0 : src;
-        }
-
-    private:
-        T thresh;
-    };
+    // threshold  
 
     template <template <typename> class Op, typename T>
     void threshold_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, T thresh, T maxVal, 
@@ -630,11 +432,11 @@ namespace cv { namespace gpu { namespace mathfunc
 
         static const caller_t callers[] = 
         {
-            threshold_caller<ThreshBinary, T>, 
-            threshold_caller<ThreshBinaryInv, T>, 
-            threshold_caller<ThreshTrunc, T>, 
-            threshold_caller<ThreshToZero, T>, 
-            threshold_caller<ThreshToZeroInv, T>
+            threshold_caller<thresh_binary_func, T>, 
+            threshold_caller<thresh_binary_inv_func, T>, 
+            threshold_caller<thresh_trunc_func, T>, 
+            threshold_caller<thresh_to_zero_func, T>, 
+            threshold_caller<thresh_to_zero_inv_func, T>
         };
 
         callers[type]((DevMem2D_<T>)src, (DevMem2D_<T>)dst, thresh, maxVal, stream);
@@ -647,4 +449,71 @@ namespace cv { namespace gpu { namespace mathfunc
     template void threshold_gpu<int>(const DevMem2D& src, const DevMem2D& dst, int thresh, int maxVal, int type, cudaStream_t stream);
     template void threshold_gpu<float>(const DevMem2D& src, const DevMem2D& dst, float thresh, float maxVal, int type, cudaStream_t stream);
     template void threshold_gpu<double>(const DevMem2D& src, const DevMem2D& dst, double thresh, double maxVal, int type, cudaStream_t stream);
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // subtract
+
+    template <typename T>
+    void subtractCaller(const DevMem2D src1, const DevMem2D src2, DevMem2D dst, cudaStream_t stream)
+    {
+        transform((DevMem2D_<T>)src1, (DevMem2D_<T>)src2, (DevMem2D_<T>)dst, minus<T>(), stream);
+    }
+
+    template void subtractCaller<short>(const DevMem2D src1, const DevMem2D src2, DevMem2D dst, cudaStream_t stream);
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // pow
+    
+    template<typename T, bool Signed = device::numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
+    {    
+        float power;
+        PowOp(float power_) : power(power_) {}
+            
+        __device__ __forceinline__ T operator()(const T& e) const
+        {      
+            return saturate_cast<T>(__powf((float)e, power));
+        }      
+    };
+
+    template<typename T> struct PowOp<T, true> : unary_function<T, T>
+    {
+        float power;
+        PowOp(float power_) : power(power_) {}
+
+        __device__ __forceinline__ float operator()(const T& e) const
+        {
+            T res = saturate_cast<T>(__powf((float)e, power));            
+            
+            if ( (e < 0) && (1 & (int)power) )
+                    res *= -1;            
+            return res;         
+        }
+    };
+
+    template<> struct PowOp<float> : unary_function<float, float>
+    {
+        float power;
+        PowOp(float power_) : power(power_) {}
+
+        __device__ __forceinline__ float operator()(const float& e) const
+        {
+            return __powf(fabs(e), power);
+        }
+    };
+
+    template<typename T>
+    void pow_caller(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream)
+    {
+        transform((DevMem2D_<T>)src, (DevMem2D_<T>)dst, PowOp<T>(power), stream);
+    }   
+
+    template void pow_caller<uchar>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<schar>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<short>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<ushort>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<int>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<uint>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+    template void pow_caller<float>(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
 }}}
diff --git a/modules/gpu/src/cuda/filters.cu b/modules/gpu/src/cuda/filters.cu
index 5b12d9dd44..fd67fb9611 100644
--- a/modules/gpu/src/cuda/filters.cu
+++ b/modules/gpu/src/cuda/filters.cu
@@ -40,14 +40,11 @@
 //
 //M*/
 
-#include "opencv2/gpu/devmem2d.hpp"
-#include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
-#include "opencv2/gpu/device/border_interpolate.hpp"
-
-#include "safe_call.hpp"
 #include "internal_shared.hpp"
+#include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
+#include "opencv2/gpu/device/limits.hpp"
+#include "opencv2/gpu/device/border_interpolate.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -76,7 +73,7 @@ namespace filter_krnls
 {
     template <typename T, size_t size> struct SmemType_
     {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_t smem_t;
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type smem_t;
     };
     template <typename T> struct SmemType_<T, 4>
     {
@@ -111,7 +108,7 @@ namespace filter_krnls
 
             if (x < src.cols)
             {
-                typedef typename TypeVec<float, VecTraits<T>::cn>::vec_t sum_t;
+                typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
                 sum_t sum = VecTraits<sum_t>::all(0);
 
                 sDataRow += threadIdx.x + BLOCK_DIM_X - anchor;
@@ -224,6 +221,7 @@ namespace cv { namespace gpu { namespace filters
     template void linearRowFilter_gpu<uchar4, float4>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearRowFilter_gpu<short , float >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearRowFilter_gpu<short2, float2>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+    template void linearRowFilter_gpu<short3, float3>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearRowFilter_gpu<int   , float >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearRowFilter_gpu<float , float >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
 }}}
@@ -252,7 +250,7 @@ namespace filter_krnls
 
             if (y < src.rows)
             {
-                typedef typename TypeVec<float, VecTraits<T>::cn>::vec_t sum_t;
+                typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
                 sum_t sum = VecTraits<sum_t>::all(0);
 
                 sDataColumn += (threadIdx.y + BLOCK_DIM_Y - anchor) * BLOCK_DIM_X;
@@ -275,7 +273,7 @@ namespace cv { namespace gpu { namespace filters
         dim3 threads(BLOCK_DIM_X, BLOCK_DIM_Y);
         dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y));
 
-        B<T> b(src.rows, src.step / src.elemSize());
+        B<T> b(src.rows, src.step);
 
         if (!b.is_range_safe(-BLOCK_DIM_Y, (grid.y + 1) * BLOCK_DIM_Y - 1))
         {
@@ -364,6 +362,7 @@ namespace cv { namespace gpu { namespace filters
     template void linearColumnFilter_gpu<float4, uchar4>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearColumnFilter_gpu<float , short >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearColumnFilter_gpu<float2, short2>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+    template void linearColumnFilter_gpu<float3, short3>(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearColumnFilter_gpu<float , int   >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
     template void linearColumnFilter_gpu<float , float >(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
 }}}
@@ -473,7 +472,7 @@ namespace bf_krnls
                     }
                 }
 
-                float minimum = numeric_limits_gpu<float>::max();
+                float minimum = numeric_limits<float>::max();
                 int id = 0;
 
                 if (cost[0] < minimum)
diff --git a/modules/gpu/src/cuda/hist.cu b/modules/gpu/src/cuda/hist.cu
new file mode 100644
index 0000000000..cafcb0909a
--- /dev/null
+++ b/modules/gpu/src/cuda/hist.cu
@@ -0,0 +1,220 @@
+/*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) 1993-2011, NVIDIA 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 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 bpied warranties, including, but not limited to, the bpied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "internal_shared.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/saturate_cast.hpp"
+
+using namespace cv::gpu;
+
+using namespace cv::gpu::device;
+
+#define UINT_BITS 32U
+
+//Warps == subhistograms per threadblock
+#define WARP_COUNT 6
+
+//Threadblock size
+#define HISTOGRAM256_THREADBLOCK_SIZE (WARP_COUNT * OPENCV_GPU_WARP_SIZE)
+#define HISTOGRAM256_BIN_COUNT 256
+
+//Shared memory per threadblock
+#define HISTOGRAM256_THREADBLOCK_MEMORY (WARP_COUNT * HISTOGRAM256_BIN_COUNT)
+
+#define PARTIAL_HISTOGRAM256_COUNT 240
+
+#define MERGE_THREADBLOCK_SIZE 256
+
+#define USE_SMEM_ATOMICS (__CUDA_ARCH__ >= 120)
+
+namespace cv { namespace gpu { namespace histograms
+{
+    #if (!USE_SMEM_ATOMICS)
+
+        #define TAG_MASK ( (1U << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE)) - 1U )
+
+        __forceinline__ __device__ void addByte(volatile uint* s_WarpHist, uint data, uint threadTag)
+        {
+            uint count;
+            do
+            {
+                count = s_WarpHist[data] & TAG_MASK;
+                count = threadTag | (count + 1);
+                s_WarpHist[data] = count;
+            } while (s_WarpHist[data] != count);
+        }
+
+    #else
+
+        #define TAG_MASK 0xFFFFFFFFU
+
+        __forceinline__ __device__ void addByte(uint* s_WarpHist, uint data, uint threadTag)
+        {
+            atomicAdd(s_WarpHist + data, 1);
+        }
+
+    #endif
+
+    __forceinline__ __device__ void addWord(uint* s_WarpHist, uint data, uint tag, uint pos_x, uint cols)
+    {
+        uint x = pos_x << 2;
+
+        if (x + 0 < cols) addByte(s_WarpHist, (data >>  0) & 0xFFU, tag);
+        if (x + 1 < cols) addByte(s_WarpHist, (data >>  8) & 0xFFU, tag);
+        if (x + 2 < cols) addByte(s_WarpHist, (data >> 16) & 0xFFU, tag);
+        if (x + 3 < cols) addByte(s_WarpHist, (data >> 24) & 0xFFU, tag);
+    }
+
+    __global__ void histogram256(const PtrStep_<uint> d_Data, uint* d_PartialHistograms, uint dataCount, uint cols)
+    {
+        //Per-warp subhistogram storage
+        __shared__ uint s_Hist[HISTOGRAM256_THREADBLOCK_MEMORY];
+        uint* s_WarpHist= s_Hist + (threadIdx.x >> OPENCV_GPU_LOG_WARP_SIZE) * HISTOGRAM256_BIN_COUNT;
+
+        //Clear shared memory storage for current threadblock before processing
+        #pragma unroll
+        for (uint i = 0; i < (HISTOGRAM256_THREADBLOCK_MEMORY / HISTOGRAM256_THREADBLOCK_SIZE); i++)
+           s_Hist[threadIdx.x + i * HISTOGRAM256_THREADBLOCK_SIZE] = 0;
+
+        //Cycle through the entire data set, update subhistograms for each warp
+        const uint tag = threadIdx.x << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE);
+
+        __syncthreads();
+        const uint colsui = d_Data.step / sizeof(uint);
+        for(uint pos = blockIdx.x * blockDim.x + threadIdx.x; pos < dataCount; pos += blockDim.x * gridDim.x)
+        {
+            uint pos_y = pos / colsui;
+            uint pos_x = pos % colsui;
+            uint data = d_Data.ptr(pos_y)[pos_x];
+            addWord(s_WarpHist, data, tag, pos_x, cols);
+        }
+
+        //Merge per-warp histograms into per-block and write to global memory
+        __syncthreads();
+        for(uint bin = threadIdx.x; bin < HISTOGRAM256_BIN_COUNT; bin += HISTOGRAM256_THREADBLOCK_SIZE)
+        {
+            uint sum = 0;
+
+            for (uint i = 0; i < WARP_COUNT; i++)
+                sum += s_Hist[bin + i * HISTOGRAM256_BIN_COUNT] & TAG_MASK;
+
+            d_PartialHistograms[blockIdx.x * HISTOGRAM256_BIN_COUNT + bin] = sum;
+        }
+    }
+
+    ////////////////////////////////////////////////////////////////////////////////
+    // Merge histogram256() output
+    // Run one threadblock per bin; each threadblock adds up the same bin counter
+    // from every partial histogram. Reads are uncoalesced, but mergeHistogram256
+    // takes only a fraction of total processing time
+    ////////////////////////////////////////////////////////////////////////////////
+
+    __global__ void mergeHistogram256(const uint* d_PartialHistograms, int* d_Histogram)
+    {
+        uint sum = 0;
+
+        #pragma unroll
+        for (uint i = threadIdx.x; i < PARTIAL_HISTOGRAM256_COUNT; i += MERGE_THREADBLOCK_SIZE)
+            sum += d_PartialHistograms[blockIdx.x + i * HISTOGRAM256_BIN_COUNT];
+
+        __shared__ uint data[MERGE_THREADBLOCK_SIZE];
+        data[threadIdx.x] = sum;
+
+        for (uint stride = MERGE_THREADBLOCK_SIZE / 2; stride > 0; stride >>= 1)
+        {
+            __syncthreads();
+            if(threadIdx.x < stride)
+                data[threadIdx.x] += data[threadIdx.x + stride];
+        }
+
+        if(threadIdx.x == 0)
+            d_Histogram[blockIdx.x] = saturate_cast<int>(data[0]);
+    }
+
+    void histogram256_gpu(DevMem2D src, int* hist, uint* buf, cudaStream_t stream)
+    {
+        histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
+            DevMem2D_<uint>(src),
+            buf, 
+            static_cast<uint>(src.rows * src.step / sizeof(uint)),
+            src.cols);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        mergeHistogram256<<<HISTOGRAM256_BIN_COUNT, MERGE_THREADBLOCK_SIZE, 0, stream>>>(buf, hist);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    __constant__ int c_lut[256];
+
+    __global__ void equalizeHist(const DevMem2D src, PtrStep dst)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x < src.cols && y < src.rows)
+        {
+            const uchar val = src.ptr(y)[x];
+            const int lut = c_lut[val];
+            dst.ptr(y)[x] = __float2int_rn(255.0f / (src.cols * src.rows) * lut);
+        }
+    }
+
+    void equalizeHist_gpu(DevMem2D src, DevMem2D dst, const int* lut, cudaStream_t stream)
+    {
+        dim3 block(16, 16);
+        dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+
+        cudaSafeCall( cudaMemcpyToSymbol(cv::gpu::histograms::c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
+
+        equalizeHist<<<grid, block, 0, stream>>>(src, dst);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}}}
diff --git a/modules/gpu/src/cuda/hog.cu b/modules/gpu/src/cuda/hog.cu
index 5afb3dfb55..6ef4c4cbb2 100644
--- a/modules/gpu/src/cuda/hog.cu
+++ b/modules/gpu/src/cuda/hog.cu
@@ -42,14 +42,6 @@
 
 #include "internal_shared.hpp"
 
-#ifndef CV_PI_F
-  #ifndef CV_PI
-    #define CV_PI_F 3.14159265f
-  #else
-    #define CV_PI_F ((float)CV_PI)
-  #endif
-#endif
-
 // Other values are not supported
 #define CELL_WIDTH 8
 #define CELL_HEIGHT 8
@@ -776,4 +768,4 @@ static void resize_for_hog(const DevMem2D& src, DevMem2D dst, TEX& tex)
 void resize_8UC1(const DevMem2D& src, DevMem2D dst) { resize_for_hog<uchar> (src, dst, resize8UC1_tex); }
 void resize_8UC4(const DevMem2D& src, DevMem2D dst) { resize_for_hog<uchar4>(src, dst, resize8UC4_tex); }
 
-}}}
\ No newline at end of file
+}}}
diff --git a/modules/gpu/src/cuda/imgproc.cu b/modules/gpu/src/cuda/imgproc.cu
index 82f578a008..4252a6be24 100644
--- a/modules/gpu/src/cuda/imgproc.cu
+++ b/modules/gpu/src/cuda/imgproc.cu
@@ -49,7 +49,7 @@ using namespace cv::gpu::device;
 /////////////////////////////////// Remap ///////////////////////////////////////////////
 namespace cv { namespace gpu { namespace imgproc
 {
-    texture<unsigned char, 2, cudaReadModeNormalizedFloat> tex_remap;
+    texture<unsigned char, 2, cudaReadModeNormalizedFloat> tex_remap(0, cudaFilterModeLinear, cudaAddressModeWrap);
 
     __global__ void remap_1c(const float* mapx, const float* mapy, size_t map_step, uchar* out, size_t out_step, int width, int height)
     {    
@@ -66,8 +66,8 @@ namespace cv { namespace gpu { namespace imgproc
         }
     }
 
-    __global__ void remap_3c(const uchar* src, size_t src_step, const float* mapx, const float* mapy, size_t map_step, 
-                             uchar* dst, size_t dst_step, int width, int height)
+    __global__ void remap_3c(const uchar* src, size_t src_step, const float* mapx, const float* mapy,
+                             size_t map_step, uchar* dst, size_t dst_step, int width, int height)
     {    
         const int x = blockDim.x * blockIdx.x + threadIdx.x;
         const int y = blockDim.y * blockIdx.y + threadIdx.y;
@@ -131,16 +131,12 @@ namespace cv { namespace gpu { namespace imgproc
         grid.x = divUp(dst.cols, threads.x);
         grid.y = divUp(dst.rows, threads.y);
 
-        tex_remap.filterMode = cudaFilterModeLinear;	    
-        tex_remap.addressMode[0] = tex_remap.addressMode[1] = cudaAddressModeWrap;
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<unsigned char>();
-        cudaSafeCall( cudaBindTexture2D(0, tex_remap, src.data, desc, src.cols, src.rows, src.step) );
+        TextureBinder tex(&tex_remap, src);
 
         remap_1c<<<grid, threads>>>(xmap.data, ymap.data, xmap.step, dst.data, dst.step, dst.cols, dst.rows);
         cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall( cudaDeviceSynchronize() );  
-        cudaSafeCall( cudaUnbindTexture(tex_remap) );
+        cudaSafeCall( cudaDeviceSynchronize() );
     }
     
     void remap_gpu_3c(const DevMem2D& src, const DevMem2Df& xmap, const DevMem2Df& ymap, DevMem2D dst)
@@ -153,7 +149,7 @@ namespace cv { namespace gpu { namespace imgproc
         remap_3c<<<grid, threads>>>(src.data, src.step, xmap.data, ymap.data, xmap.step, dst.data, dst.step, dst.cols, dst.rows);
         cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall( cudaDeviceSynchronize() ); 
+        cudaSafeCall( cudaDeviceSynchronize() );
     }
 
 /////////////////////////////////// MeanShiftfiltering ///////////////////////////////////////////////
@@ -161,7 +157,7 @@ namespace cv { namespace gpu { namespace imgproc
     texture<uchar4, 2> tex_meanshift;
 
     __device__ short2 do_mean_shift(int x0, int y0, unsigned char* out, 
-                                    int out_step, int cols, int rows, 
+                                    size_t out_step, int cols, int rows, 
                                     int sp, int sr, int maxIter, float eps)
     {
         int isr2 = sr*sr;
@@ -225,7 +221,7 @@ namespace cv { namespace gpu { namespace imgproc
         return make_short2((short)x0, (short)y0);
     }
 
-    extern "C" __global__ void meanshift_kernel( unsigned char* out, int out_step, int cols, int rows, 
+    extern "C" __global__ void meanshift_kernel( unsigned char* out, size_t out_step, int cols, int rows, 
                                                  int sp, int sr, int maxIter, float eps )
     {
         int x0 = blockIdx.x * blockDim.x + threadIdx.x;
@@ -235,8 +231,8 @@ namespace cv { namespace gpu { namespace imgproc
             do_mean_shift(x0, y0, out, out_step, cols, rows, sp, sr, maxIter, eps);
     }
 
-    extern "C" __global__ void meanshiftproc_kernel( unsigned char* outr, int outrstep, 
-                                                 unsigned char* outsp, int outspstep, 
+    extern "C" __global__ void meanshiftproc_kernel( unsigned char* outr, size_t outrstep, 
+                                                 unsigned char* outsp, size_t outspstep, 
                                                  int cols, int rows, 
                                                  int sp, int sr, int maxIter, float eps )
     {
@@ -251,9 +247,9 @@ namespace cv { namespace gpu { namespace imgproc
     }
 
     extern "C" void meanShiftFiltering_gpu(const DevMem2D& src, DevMem2D dst, int sp, int sr, int maxIter, float eps)
-    {                        
+    {
         dim3 grid(1, 1, 1);
-        dim3 threads(32, 16, 1);
+        dim3 threads(32, 8, 1);
         grid.x = divUp(src.cols, threads.x);
         grid.y = divUp(src.rows, threads.y);
 
@@ -269,7 +265,7 @@ namespace cv { namespace gpu { namespace imgproc
     extern "C" void meanShiftProc_gpu(const DevMem2D& src, DevMem2D dstr, DevMem2D dstsp, int sp, int sr, int maxIter, float eps) 
     {
         dim3 grid(1, 1, 1);
-        dim3 threads(32, 16, 1);
+        dim3 threads(32, 8, 1);
         grid.x = divUp(src.cols, threads.x);
         grid.y = divUp(src.rows, threads.y);
 
@@ -768,6 +764,7 @@ namespace cv { namespace gpu { namespace imgproc
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
+
     //////////////////////////////////////////////////////////////////////////
     // mulSpectrums
 
@@ -796,6 +793,7 @@ namespace cv { namespace gpu { namespace imgproc
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
+
     //////////////////////////////////////////////////////////////////////////
     // mulSpectrums_CONJ
 
@@ -825,6 +823,7 @@ namespace cv { namespace gpu { namespace imgproc
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
+
     //////////////////////////////////////////////////////////////////////////
     // mulAndScaleSpectrums
 
@@ -855,6 +854,7 @@ namespace cv { namespace gpu { namespace imgproc
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
+
     //////////////////////////////////////////////////////////////////////////
     // mulAndScaleSpectrums_CONJ
 
@@ -885,34 +885,272 @@ namespace cv { namespace gpu { namespace imgproc
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
+
     /////////////////////////////////////////////////////////////////////////
     // downsample
 
-    template <typename T>
-    __global__ void downsampleKernel(const PtrStep_<T> src, int rows, int cols, int k, PtrStep_<T> dst)
+    template <typename T, int cn>
+    __global__ void downsampleKernel(const PtrStep_<T> src, DevMem2D_<T> dst)
     {
         int x = blockIdx.x * blockDim.x + threadIdx.x;
         int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x < cols && y < rows)
-            dst.ptr(y)[x] = src.ptr(y * k)[x * k];
+        if (x < dst.cols && y < dst.rows)
+        {
+            int ch_x = x / cn;
+            dst.ptr(y)[x] = src.ptr(y*2)[ch_x*2*cn + x - ch_x*cn];
+        }
     }
 
 
-    template <typename T>
-    void downsampleCaller(const PtrStep_<T> src, int rows, int cols, int k, PtrStep_<T> dst)
+    template <typename T, int cn>
+    void downsampleCaller(const DevMem2D src, DevMem2D dst, cudaStream_t stream)
     {
-        dim3 threads(16, 16);
+        dim3 threads(32, 8);
+        dim3 grid(divUp(dst.cols, threads.x), divUp(dst.rows, threads.y));
+
+        downsampleKernel<T,cn><<<grid, threads, 0, stream>>>(DevMem2D_<T>(src), DevMem2D_<T>(dst));
+        cudaSafeCall(cudaGetLastError());
+        
+        if (stream == 0)
+            cudaSafeCall(cudaDeviceSynchronize());
+    }
+
+
+    template void downsampleCaller<uchar,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<uchar,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<uchar,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<uchar,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<short,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<short,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<short,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<short,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<float,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<float,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<float,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void downsampleCaller<float,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // upsample
+
+    template <typename T, int cn>
+    __global__ void upsampleKernel(const PtrStep_<T> src, DevMem2D_<T> dst)
+    {
+        int x = blockIdx.x * blockDim.x + threadIdx.x;
+        int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x < dst.cols && y < dst.rows)
+        {
+            int ch_x = x / cn;
+            T val = ((ch_x & 1) || (y & 1)) ? 0 : src.ptr(y/2)[ch_x/2*cn + x - ch_x*cn];
+            dst.ptr(y)[x] = val;
+        }
+    }
+
+
+    template <typename T, int cn>
+    void upsampleCaller(const DevMem2D src, DevMem2D dst, cudaStream_t stream)
+    {
+        dim3 threads(32, 8);
+        dim3 grid(divUp(dst.cols, threads.x), divUp(dst.rows, threads.y));
+
+        upsampleKernel<T,cn><<<grid, threads, 0, stream>>>(DevMem2D_<T>(src), DevMem2D_<T>(dst));
+        cudaSafeCall(cudaGetLastError());
+
+        if (stream == 0)
+            cudaSafeCall(cudaDeviceSynchronize());
+    }
+
+
+    template void upsampleCaller<uchar,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<uchar,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<uchar,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<uchar,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<short,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<short,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<short,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<short,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<float,1>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<float,2>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<float,3>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+    template void upsampleCaller<float,4>(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // buildWarpMaps
+
+    namespace build_warp_maps
+    {
+        __constant__ float cr[9];
+        __constant__ float crinv[9];
+        __constant__ float cf, cs;
+        __constant__ float chalf_w, chalf_h;
+        __constant__ float cdist;
+    }
+
+
+    class PlaneMapper
+    {
+    public:
+        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
+        {
+            using namespace build_warp_maps;
+
+            float x_ = u / cs;
+            float y_ = v / cs;
+
+            float z;
+            x = crinv[0]*x_ + crinv[1]*y_ + crinv[2]*cdist;
+            y = crinv[3]*x_ + crinv[4]*y_ + crinv[5]*cdist;
+            z = crinv[6]*x_ + crinv[7]*y_ + crinv[8]*cdist;
+
+            x = cf*x/z + chalf_w;
+            y = cf*y/z + chalf_h;
+        }
+    };
+
+
+    class CylindricalMapper
+    {
+    public:
+        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
+        {
+            using namespace build_warp_maps;
+
+            u /= cs;
+            float x_ = sinf(u);
+            float y_ = v / cs;
+            float z_ = cosf(u);
+
+            float z;
+            x = crinv[0]*x_ + crinv[1]*y_ + crinv[2]*z_;
+            y = crinv[3]*x_ + crinv[4]*y_ + crinv[5]*z_;
+            z = crinv[6]*x_ + crinv[7]*y_ + crinv[8]*z_;
+
+            x = cf*x/z + chalf_w;
+            y = cf*y/z + chalf_h;
+        }
+    };
+
+
+    class SphericalMapper
+    {
+    public:
+        static __device__ __forceinline__ void mapBackward(float u, float v, float &x, float &y)
+        {
+            using namespace build_warp_maps;
+
+            v /= cs;
+            u /= cs;
+
+            float sinv = sinf(v);
+            float x_ = sinv * sinf(u);
+            float y_ = -cosf(v);
+            float z_ = sinv * cosf(u);
+
+            float z;
+            x = crinv[0]*x_ + crinv[1]*y_ + crinv[2]*z_;
+            y = crinv[3]*x_ + crinv[4]*y_ + crinv[5]*z_;
+            z = crinv[6]*x_ + crinv[7]*y_ + crinv[8]*z_;
+
+            x = cf*x/z + chalf_w;
+            y = cf*y/z + chalf_h;
+        }
+    };
+
+
+    template <typename Mapper>
+    __global__ void buildWarpMapsKernel(int tl_u, int tl_v, int cols, int rows,
+                                        PtrStepf map_x, PtrStepf map_y)
+    {
+        int du = blockIdx.x * blockDim.x + threadIdx.x;
+        int dv = blockIdx.y * blockDim.y + threadIdx.y;
+        if (du < cols && dv < rows)
+        {
+            float u = tl_u + du;
+            float v = tl_v + dv;
+            float x, y;
+            Mapper::mapBackward(u, v, x, y);
+            map_x.ptr(dv)[du] = x;
+            map_y.ptr(dv)[du] = y;
+        }
+    }
+
+
+    void buildWarpPlaneMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                            const float r[9], const float rinv[9], float f, float s, float dist,
+                            float half_w, float half_h, cudaStream_t stream)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr, r, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::crinv, rinv, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cf, &f, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cs, &s, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_w, &half_w, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_h, &half_h, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cdist, &dist, sizeof(float)));
+
+        int cols = map_x.cols;
+        int rows = map_x.rows;
+
+        dim3 threads(32, 8);
         dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
 
-        downsampleKernel<<<grid, threads>>>(src, rows, cols, k, dst);
-        cudaSafeCall( cudaGetLastError() );
-
-        cudaSafeCall( cudaDeviceSynchronize() );
+        buildWarpMapsKernel<PlaneMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+        cudaSafeCall(cudaGetLastError());
+        if (stream == 0)
+            cudaSafeCall(cudaDeviceSynchronize());
+    }
+
+
+    void buildWarpCylindricalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                                  const float r[9], const float rinv[9], float f, float s,
+                                  float half_w, float half_h, cudaStream_t stream)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr, r, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::crinv, rinv, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cf, &f, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cs, &s, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_w, &half_w, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_h, &half_h, sizeof(float)));
+
+        int cols = map_x.cols;
+        int rows = map_x.rows;
+
+        dim3 threads(32, 8);
+        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+
+        buildWarpMapsKernel<CylindricalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+        cudaSafeCall(cudaGetLastError());
+        if (stream == 0)
+            cudaSafeCall(cudaDeviceSynchronize());
+    }
+
+
+    void buildWarpSphericalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                                const float r[9], const float rinv[9], float f, float s,
+                                float half_w, float half_h, cudaStream_t stream)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cr, r, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::crinv, rinv, 9*sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cf, &f, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::cs, &s, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_w, &half_w, sizeof(float)));
+        cudaSafeCall(cudaMemcpyToSymbol(build_warp_maps::chalf_h, &half_h, sizeof(float)));
+
+        int cols = map_x.cols;
+        int rows = map_x.rows;
+
+        dim3 threads(32, 8);
+        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+
+        buildWarpMapsKernel<SphericalMapper><<<grid,threads>>>(tl_u, tl_v, cols, rows, map_x, map_y);
+        cudaSafeCall(cudaGetLastError());
+        if (stream == 0)
+            cudaSafeCall(cudaDeviceSynchronize());
     }
 
-    template void downsampleCaller(const PtrStep src, int rows, int cols, int k, PtrStep dst);
-    template void downsampleCaller(const PtrStepf src, int rows, int cols, int k, PtrStepf dst);
 
 }}}
 
+
diff --git a/modules/gpu/src/cuda/internal_shared.hpp b/modules/gpu/src/cuda/internal_shared.hpp
index 6e3f54ec20..9a3086b67b 100644
--- a/modules/gpu/src/cuda/internal_shared.hpp
+++ b/modules/gpu/src/cuda/internal_shared.hpp
@@ -49,6 +49,14 @@
 #include "npp.h"
 #include "NPP_staging.hpp"
 
+#ifndef CV_PI_F
+  #ifndef CV_PI
+    #define CV_PI_F 3.14159265f
+  #else
+    #define CV_PI_F ((float)CV_PI)
+  #endif
+#endif
+
 namespace cv
 {
     namespace gpu
@@ -69,7 +77,6 @@ namespace cv
         // Returns true if the GPU analogue exists, false otherwise.
         bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
 
-
         static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
 
         template<class T> static inline void uploadConstant(const char* name, const T& value) 
@@ -109,6 +116,49 @@ namespace cv
             cudaSafeCall( cudaUnbindTexture(tex) );
         }
 
+        class TextureBinder
+        {
+        public:
+            TextureBinder() : tex_(0) {}
+            template <typename T> TextureBinder(const textureReference* tex, const DevMem2D_<T>& img) : tex_(0)
+            {
+                bind(tex, img);
+            }
+            template <typename T> TextureBinder(const char* tex_name, const DevMem2D_<T>& img) : tex_(0)
+            {
+                bind(tex_name, img);
+            }
+            ~TextureBinder() { unbind(); }
+
+            template <typename T> void bind(const textureReference* tex, const DevMem2D_<T>& img)
+            {
+                unbind();
+
+                cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+                cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+
+                tex_ = tex;
+            }
+            template <typename T> void bind(const char* tex_name, const DevMem2D_<T>& img)
+            {
+                const textureReference* tex; 
+                cudaSafeCall( cudaGetTextureReference(&tex, tex_name) ); 
+                bind(tex, img);
+            }
+
+            void unbind()
+            {
+                if (tex_)
+                {
+                    cudaUnbindTexture(tex_);
+                    tex_ = 0;
+                }
+            }
+
+        private:
+            const textureReference* tex_;
+        };
+
         class NppStreamHandler
         {
         public:
diff --git a/modules/gpu/src/cuda/match_template.cu b/modules/gpu/src/cuda/match_template.cu
index a46ddc31f1..301a0b6559 100644
--- a/modules/gpu/src/cuda/match_template.cu
+++ b/modules/gpu/src/cuda/match_template.cu
@@ -41,7 +41,7 @@
 //M*/
 
 #include "internal_shared.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -84,8 +84,8 @@ __global__ void matchTemplateNaiveKernel_CCORR(
         int w, int h, const PtrStep image, const PtrStep templ, 
         DevMem2Df result)
 {
-    typedef typename TypeVec<T, cn>::vec_t Type;
-    typedef typename TypeVec<float, cn>::vec_t Typef;
+    typedef typename TypeVec<T, cn>::vec_type Type;
+    typedef typename TypeVec<float, cn>::vec_type Typef;
 
     int x = blockDim.x * blockIdx.x + threadIdx.x;
     int y = blockDim.y * blockIdx.y + threadIdx.y;
@@ -174,8 +174,8 @@ __global__ void matchTemplateNaiveKernel_SQDIFF(
         int w, int h, const PtrStep image, const PtrStep templ, 
         DevMem2Df result)
 {
-    typedef typename TypeVec<T, cn>::vec_t Type;
-    typedef typename TypeVec<float, cn>::vec_t Typef;
+    typedef typename TypeVec<T, cn>::vec_type Type;
+    typedef typename TypeVec<float, cn>::vec_type Typef;
 
     int x = blockDim.x * blockIdx.x + threadIdx.x;
     int y = blockDim.y * blockIdx.y + threadIdx.y;
@@ -884,7 +884,7 @@ void normalize_8U(int w, int h, const DevMem2D_<unsigned long long> image_sqsum,
 template <int cn>
 __global__ void extractFirstChannel_32F(const PtrStep image, DevMem2Df result)
 {
-    typedef typename TypeVec<float, cn>::vec_t Typef;
+    typedef typename TypeVec<float, cn>::vec_type Typef;
 
     int x = blockDim.x * blockIdx.x + threadIdx.x;
     int y = blockDim.y * blockIdx.y + threadIdx.y;
diff --git a/modules/gpu/src/cuda/mathfunc.cu b/modules/gpu/src/cuda/mathfunc.cu
index bed7a0421a..b5ee973038 100644
--- a/modules/gpu/src/cuda/mathfunc.cu
+++ b/modules/gpu/src/cuda/mathfunc.cu
@@ -40,9 +40,9 @@
 //
 //M*/
 
-#include "opencv2/gpu/device/limits_gpu.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "internal_shared.hpp"
 
@@ -82,7 +82,9 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float scale)
         {
-            dst[y * dst_step + x] = scale * atan2f(y_data, x_data);
+            float angle = atan2f(y_data, x_data);
+            angle += (angle < 0) * 2.0 * CV_PI;
+            dst[y * dst_step + x] = scale * angle;
         }
     };
     template <typename Mag, typename Angle>
diff --git a/modules/gpu/src/cuda/matrix_operations.cu b/modules/gpu/src/cuda/matrix_operations.cu
index 40f15886c6..3636853b4d 100644
--- a/modules/gpu/src/cuda/matrix_operations.cu
+++ b/modules/gpu/src/cuda/matrix_operations.cu
@@ -43,6 +43,7 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/functional.hpp"
 
 using namespace cv::gpu::device;
 
@@ -62,7 +63,7 @@ namespace cv { namespace gpu { namespace matrix_operations {
 ///////////////////////////////////////////////////////////////////////////
 
     template<typename T>
-    __global__ void copy_to_with_mask(T * mat_src, T * mat_dst, const unsigned char * mask, int cols, int rows, int step_mat, int step_mask, int channels)
+    __global__ void copy_to_with_mask(const T* mat_src, T* mat_dst, const uchar* mask, int cols, int rows, size_t step_mat, size_t step_mask, int channels)
     {
         size_t x = blockIdx.x * blockDim.x + threadIdx.x;
         size_t y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -162,7 +163,7 @@ namespace cv { namespace gpu { namespace matrix_operations {
     }
 
     template<typename T>
-    __global__ void set_to_without_mask(T * mat, int cols, int rows, int step, int channels)
+    __global__ void set_to_without_mask(T* mat, int cols, int rows, size_t step, int channels)
     {
         size_t x = blockIdx.x * blockDim.x + threadIdx.x;
         size_t y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -175,7 +176,7 @@ namespace cv { namespace gpu { namespace matrix_operations {
     }
 
     template<typename T>
-    __global__ void set_to_with_mask(T * mat, const unsigned char * mask, int cols, int rows, int step, int channels, int step_mask)
+    __global__ void set_to_with_mask(T* mat, const uchar* mask, int cols, int rows, size_t step, int channels, size_t step_mask)
     {
         size_t x = blockIdx.x * blockDim.x + threadIdx.x;
         size_t y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -237,19 +238,16 @@ namespace cv { namespace gpu { namespace matrix_operations {
 //////////////////////////////// ConvertTo ////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    template <typename T, typename D>
-    class Convertor
+    template <typename T, typename D> struct Convertor : unary_function<T, D>
     {
-    public:
         Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
 
-        __device__ __forceinline__ D operator()(const T& src)
+        __device__ __forceinline__ D operator()(const T& src) const
         {
             return saturate_cast<D>(alpha * src + beta);
         }
 
-    private:
-        double alpha, beta;
+        const double alpha, beta;
     };
     
     template<typename T, typename D>
diff --git a/modules/gpu/src/cuda/matrix_reductions.cu b/modules/gpu/src/cuda/matrix_reductions.cu
index 27224c6f78..60e6c886e8 100644
--- a/modules/gpu/src/cuda/matrix_reductions.cu
+++ b/modules/gpu/src/cuda/matrix_reductions.cu
@@ -40,9 +40,9 @@
 //
 //M*/
 
-#include "opencv2/gpu/device/limits_gpu.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "internal_shared.hpp"
 
@@ -190,8 +190,8 @@ namespace cv { namespace gpu { namespace mathfunc
         uint y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-        T mymin = numeric_limits_gpu<T>::max();
-        T mymax = numeric_limits_gpu<T>::is_signed ? -numeric_limits_gpu<T>::max() : numeric_limits_gpu<T>::min();
+        T mymin = numeric_limits<T>::max();
+        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : numeric_limits<T>::min();
         uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
         uint x_end = min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
         for (uint y = y0; y < y_end; y += blockDim.y)
@@ -512,9 +512,9 @@ namespace cv { namespace gpu { namespace mathfunc
         uint y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-        T mymin = numeric_limits_gpu<T>::max();
-        T mymax = numeric_limits_gpu<T>::is_signed ? -numeric_limits_gpu<T>::max() : 
-                                                     numeric_limits_gpu<T>::min(); 
+        T mymin = numeric_limits<T>::max();
+        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : 
+                                                     numeric_limits<T>::min(); 
         uint myminloc = 0;
         uint mymaxloc = 0;
         uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
@@ -1094,10 +1094,10 @@ namespace cv { namespace gpu { namespace mathfunc
 
 
     template <typename T, typename R, typename Op, int nthreads>
-    __global__ void sumKernel_C2(const DevMem2D src, typename TypeVec<R, 2>::vec_t* result)
+    __global__ void sumKernel_C2(const DevMem2D src, typename TypeVec<R, 2>::vec_type* result)
     {
-        typedef typename TypeVec<T, 2>::vec_t SrcType;
-        typedef typename TypeVec<R, 2>::vec_t DstType;
+        typedef typename TypeVec<T, 2>::vec_type SrcType;
+        typedef typename TypeVec<R, 2>::vec_type DstType;
 
         __shared__ R smem[nthreads * 2];
 
@@ -1173,9 +1173,9 @@ namespace cv { namespace gpu { namespace mathfunc
 
 
     template <typename T, typename R, int nthreads>
-    __global__ void sumPass2Kernel_C2(typename TypeVec<R, 2>::vec_t* result, int size)
+    __global__ void sumPass2Kernel_C2(typename TypeVec<R, 2>::vec_type* result, int size)
     {
-        typedef typename TypeVec<R, 2>::vec_t DstType;
+        typedef typename TypeVec<R, 2>::vec_type DstType;
 
         __shared__ R smem[nthreads * 2];
 
@@ -1199,10 +1199,10 @@ namespace cv { namespace gpu { namespace mathfunc
 
 
     template <typename T, typename R, typename Op, int nthreads>
-    __global__ void sumKernel_C3(const DevMem2D src, typename TypeVec<R, 3>::vec_t* result)
+    __global__ void sumKernel_C3(const DevMem2D src, typename TypeVec<R, 3>::vec_type* result)
     {
-        typedef typename TypeVec<T, 3>::vec_t SrcType;
-        typedef typename TypeVec<R, 3>::vec_t DstType;
+        typedef typename TypeVec<T, 3>::vec_type SrcType;
+        typedef typename TypeVec<R, 3>::vec_type DstType;
 
         __shared__ R smem[nthreads * 3];
 
@@ -1285,9 +1285,9 @@ namespace cv { namespace gpu { namespace mathfunc
 
 
     template <typename T, typename R, int nthreads>
-    __global__ void sumPass2Kernel_C3(typename TypeVec<R, 3>::vec_t* result, int size)
+    __global__ void sumPass2Kernel_C3(typename TypeVec<R, 3>::vec_type* result, int size)
     {
-        typedef typename TypeVec<R, 3>::vec_t DstType;
+        typedef typename TypeVec<R, 3>::vec_type DstType;
 
         __shared__ R smem[nthreads * 3];
 
@@ -1313,10 +1313,10 @@ namespace cv { namespace gpu { namespace mathfunc
     }
 
     template <typename T, typename R, typename Op, int nthreads>
-    __global__ void sumKernel_C4(const DevMem2D src, typename TypeVec<R, 4>::vec_t* result)
+    __global__ void sumKernel_C4(const DevMem2D src, typename TypeVec<R, 4>::vec_type* result)
     {
-        typedef typename TypeVec<T, 4>::vec_t SrcType;
-        typedef typename TypeVec<R, 4>::vec_t DstType;
+        typedef typename TypeVec<T, 4>::vec_type SrcType;
+        typedef typename TypeVec<R, 4>::vec_type DstType;
 
         __shared__ R smem[nthreads * 4];
 
@@ -1407,9 +1407,9 @@ namespace cv { namespace gpu { namespace mathfunc
 
 
     template <typename T, typename R, int nthreads>
-    __global__ void sumPass2Kernel_C4(typename TypeVec<R, 4>::vec_t* result, int size)
+    __global__ void sumPass2Kernel_C4(typename TypeVec<R, 4>::vec_type* result, int size)
     {
-        typedef typename TypeVec<R, 4>::vec_t DstType;
+        typedef typename TypeVec<R, 4>::vec_type DstType;
 
         __shared__ R smem[nthreads * 4];
 
@@ -1454,41 +1454,41 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 1>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 2:
             sumKernel_C2<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 2>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 3:
             sumKernel_C3<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 3>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 4:
             sumKernel_C4<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 4>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
@@ -1526,19 +1526,19 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             break;
         case 2:
             sumKernel_C2<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             break;
         case 3:
             sumKernel_C3<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             break;
         case 4:
             sumKernel_C4<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             break;
         }
         cudaSafeCall( cudaGetLastError() );
@@ -1576,41 +1576,41 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 1>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 2:
             sumKernel_C2<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 2>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 3:
             sumKernel_C3<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 3>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 4:
             sumKernel_C4<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 4>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
@@ -1648,19 +1648,19 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             break;
         case 2:
             sumKernel_C2<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             break;
         case 3:
             sumKernel_C3<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             break;
         case 4:
             sumKernel_C4<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             break;
         }
         cudaSafeCall( cudaGetLastError() );
@@ -1698,41 +1698,41 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 1>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 2:
             sumKernel_C2<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 2>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 3:
             sumKernel_C3<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 3>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
         case 4:
             sumKernel_C4<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             cudaSafeCall( cudaGetLastError() );
 
             sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                    (typename TypeVec<R, 4>::vec_t*)buf.ptr(0), grid.x * grid.y);
+                    (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
             cudaSafeCall( cudaGetLastError() );
 
             break;
@@ -1770,19 +1770,19 @@ namespace cv { namespace gpu { namespace mathfunc
         {
         case 1:
             sumKernel<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 1>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
             break;
         case 2:
             sumKernel_C2<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 2>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
             break;
         case 3:
             sumKernel_C3<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 3>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
             break;
         case 4:
             sumKernel_C4<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                    src, (typename TypeVec<R, 4>::vec_t*)buf.ptr(0));
+                    src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
             break;
         }
         cudaSafeCall( cudaGetLastError() );
diff --git a/modules/gpu/src/cuda/split_merge.cu b/modules/gpu/src/cuda/split_merge.cu
index 361a617b99..1f5ad73e81 100644
--- a/modules/gpu/src/cuda/split_merge.cu
+++ b/modules/gpu/src/cuda/split_merge.cu
@@ -40,7 +40,6 @@
 //
 //M*/
 
-#include "opencv2/gpu/devmem2d.hpp"
 #include "internal_shared.hpp"
 
 namespace cv { namespace gpu { namespace split_merge {
@@ -276,7 +275,7 @@ namespace cv { namespace gpu { namespace split_merge {
 
 
     extern "C" void merge_caller(const DevMem2D* src, DevMem2D& dst,
-                                 int total_channels, int elem_size,
+                                 int total_channels, size_t elem_size,
                                  const cudaStream_t& stream)
     {
         static MergeFunction merge_func_tbl[] =
@@ -286,7 +285,7 @@ namespace cv { namespace gpu { namespace split_merge {
             mergeC4_<char>, mergeC4_<short>, mergeC4_<int>, 0, mergeC4_<double>,
         };
 
-        int merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
+        size_t merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
         MergeFunction merge_func = merge_func_tbl[merge_func_id];
 
         if (merge_func == 0)
@@ -485,7 +484,7 @@ namespace cv { namespace gpu { namespace split_merge {
 
 
     extern "C" void split_caller(const DevMem2D& src, DevMem2D* dst,
-                                 int num_channels, int elem_size1,
+                                 int num_channels, size_t elem_size1,
                                  const cudaStream_t& stream)
     {
         static SplitFunction split_func_tbl[] =
@@ -495,7 +494,7 @@ namespace cv { namespace gpu { namespace split_merge {
             splitC4_<char>, splitC4_<short>, splitC4_<int>, 0, splitC4_<double>,
         };
 
-        int split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
+        size_t split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
         SplitFunction split_func = split_func_tbl[split_func_id];
 
         if (split_func == 0)
diff --git a/modules/gpu/src/cuda/stereobp.cu b/modules/gpu/src/cuda/stereobp.cu
index b025914b33..e0f5fd4069 100644
--- a/modules/gpu/src/cuda/stereobp.cu
+++ b/modules/gpu/src/cuda/stereobp.cu
@@ -40,10 +40,9 @@
 //
 //M*/
 
-#include "opencv2/gpu/devmem2d.hpp"
+#include "internal_shared.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
-#include "safe_call.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -381,7 +380,7 @@ namespace cv { namespace gpu { namespace bp
     template <typename T>
     __device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
     {
-        float minimum = numeric_limits_gpu<float>::max();
+        float minimum = numeric_limits<float>::max();
 
         for(int i = 0; i < cndisp; ++i)
         {
@@ -486,7 +485,7 @@ namespace cv { namespace gpu { namespace bp
             size_t disp_step = disp.rows * u.step;
 
             int best = 0;
-            float best_val = numeric_limits_gpu<float>::max();
+            float best_val = numeric_limits<float>::max();
             for (int d = 0; d < cndisp; ++d)
             {
                 float val  = us[d * disp_step];
diff --git a/modules/gpu/src/cuda/stereocsbp.cu b/modules/gpu/src/cuda/stereocsbp.cu
index bce1f0769e..f3f0680db9 100644
--- a/modules/gpu/src/cuda/stereocsbp.cu
+++ b/modules/gpu/src/cuda/stereocsbp.cu
@@ -40,10 +40,9 @@
 //
 //M*/
 
-#include "opencv2/gpu/devmem2d.hpp"
+#include "internal_shared.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
-#include "safe_call.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -147,7 +146,7 @@ namespace cv { namespace gpu { namespace csbp
 
             for(int i = 0; i < nr_plane; i++)
             {
-                T minimum = numeric_limits_gpu<T>::max();
+                T minimum = numeric_limits<T>::max();
                 int id = 0;
                 for(int d = 0; d < cndisp; d++)
                 {
@@ -161,7 +160,7 @@ namespace cv { namespace gpu { namespace csbp
 
                 data_cost_selected[i  * cdisp_step1] = minimum;
                 selected_disparity[i  * cdisp_step1] = id;
-                data_cost         [id * cdisp_step1] = numeric_limits_gpu<T>::max();
+                data_cost         [id * cdisp_step1] = numeric_limits<T>::max();
             }
         }
     }
@@ -192,7 +191,7 @@ namespace cv { namespace gpu { namespace csbp
                     data_cost_selected[nr_local_minimum * cdisp_step1] = cur;
                     selected_disparity[nr_local_minimum * cdisp_step1] = d;
 
-                    data_cost[d * cdisp_step1] = numeric_limits_gpu<T>::max();
+                    data_cost[d * cdisp_step1] = numeric_limits<T>::max();
 
                     nr_local_minimum++;
                 }
@@ -203,7 +202,7 @@ namespace cv { namespace gpu { namespace csbp
 
             for (int i = nr_local_minimum; i < nr_plane; i++)
             {
-                T minimum = numeric_limits_gpu<T>::max();
+                T minimum = numeric_limits<T>::max();
                 int id = 0;
 
                 for (int d = 0; d < cndisp; d++)
@@ -218,7 +217,7 @@ namespace cv { namespace gpu { namespace csbp
                 data_cost_selected[i * cdisp_step1] = minimum;
                 selected_disparity[i * cdisp_step1] = id;
 
-                data_cost[id * cdisp_step1] = numeric_limits_gpu<T>::max();
+                data_cost[id * cdisp_step1] = numeric_limits<T>::max();
             }
         }
     }
@@ -610,7 +609,7 @@ namespace cv { namespace gpu { namespace csbp
     {
         for(int i = 0; i < nr_plane; i++)
         {
-            T minimum = numeric_limits_gpu<T>::max();
+            T minimum = numeric_limits<T>::max();
             int id = 0;
             for(int j = 0; j < nr_plane2; j++)
             {
@@ -630,7 +629,7 @@ namespace cv { namespace gpu { namespace csbp
             l_new[i * cdisp_step1] = l_cur[id * cdisp_step2];
             r_new[i * cdisp_step1] = r_cur[id * cdisp_step2];
 
-            data_cost_new[id * cdisp_step1] = numeric_limits_gpu<T>::max();
+            data_cost_new[id * cdisp_step1] = numeric_limits<T>::max();
         }
     }
 
@@ -737,7 +736,7 @@ namespace cv { namespace gpu { namespace csbp
     __device__ void message_per_pixel(const T* data, T* msg_dst, const T* msg1, const T* msg2, const T* msg3,
                                       const T* dst_disp, const T* src_disp, int nr_plane, T* temp)
     {
-        T minimum = numeric_limits_gpu<T>::max();
+        T minimum = numeric_limits<T>::max();
 
         for(int d = 0; d < nr_plane; d++)
         {
@@ -850,7 +849,7 @@ namespace cv { namespace gpu { namespace csbp
             const T* r = r_ + (y+0) * cmsg_step1 + (x-1);
 
             int best = 0;
-            T best_val = numeric_limits_gpu<T>::max();
+            T best_val = numeric_limits<T>::max();
             for (int i = 0; i < nr_plane; ++i)
             {
                 int idx = i * cdisp_step1;
diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index 3d0a74701a..a22077e2f6 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -46,8 +46,10 @@
 //M*/
 
 #include "internal_shared.hpp"
-#include "opencv2/gpu/device/limits_gpu.hpp"
+#include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/functional.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -223,7 +225,7 @@ namespace cv { namespace gpu { namespace surf
     };
 
     template <typename Mask>
-    __global__ void icvFindMaximaInLayer(PtrStepf det, PtrStepf trace, int4* maxPosBuffer, unsigned int* maxCounter)
+    __global__ void icvFindMaximaInLayer(const PtrStepf det, const PtrStepf trace, int4* maxPosBuffer, unsigned int* maxCounter)
     {
         #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
 
@@ -344,7 +346,7 @@ namespace cv { namespace gpu { namespace surf
     ////////////////////////////////////////////////////////////////////////
     // INTERPOLATION
     
-    __global__ void icvInterpolateKeypoint(PtrStepf det, const int4* maxPosBuffer,
+    __global__ void icvInterpolateKeypoint(const PtrStepf det, const int4* maxPosBuffer,
         float* featureX, float* featureY, int* featureLaplacian, float* featureSize, float* featureHessian,
         unsigned int* featureCounter)
     {
@@ -393,31 +395,10 @@ namespace cv { namespace gpu { namespace surf
             //dss
             H[2][2] = N9[0][1][1] - 2.0f * N9[1][1][1] + N9[2][1][1];
 
-            float det = H[0][0] * (H[1][1] * H[2][2] - H[1][2] * H[2][1])
-              - H[0][1] * (H[1][0] * H[2][2] - H[1][2] * H[2][0])
-              + H[0][2] * (H[1][0] * H[2][1] - H[1][1] * H[2][0]);
+            __shared__ float x[3];
 
-            if (det != 0.0f)
+            if (solve3x3(H, dD, x))
             {
-                float invdet = 1.0f / det;
-
-                __shared__ float x[3];
-
-                x[0] = invdet * 
-                    (dD[0] * (H[1][1] * H[2][2] - H[1][2] * H[2][1]) -
-                     H[0][1] * (dD[1] * H[2][2] - H[1][2] * dD[2]) +
-                     H[0][2] * (dD[1] * H[2][1] - H[1][1] * dD[2]));
-
-                x[1] = invdet * 
-                    (H[0][0] * (dD[1] * H[2][2] - H[1][2] * dD[2]) -
-                     dD[0] * (H[1][0] * H[2][2] - H[1][2] * H[2][0]) +
-                     H[0][2] * (H[1][0] * dD[2] - dD[1] * H[2][0]));
-
-                x[2] = invdet * 
-                    (H[0][0] * (H[1][1] * dD[2] - dD[1] * H[2][1]) -
-                     H[0][1] * (H[1][0] * dD[2] - dD[1] * H[2][0]) +
-                     dD[0] * (H[1][0] * H[2][1] - H[1][1] * H[2][0]));
-
                 if (fabs(x[0]) <= 1.f && fabs(x[1]) <= 1.f && fabs(x[2]) <= 1.f)
                 {
                     // if the step is within the interpolation region, perform it
@@ -500,20 +481,6 @@ namespace cv { namespace gpu { namespace surf
     __constant__ float c_NX[2][5] = {{0, 0, 2, 4, -1}, {2, 0, 4, 4, 1}};
     __constant__ float c_NY[2][5] = {{0, 0, 4, 2, 1}, {0, 2, 4, 4, -1}};
 
-    __device__ void reduceSum32(volatile float* v_sum, float& sum)
-    {
-        v_sum[threadIdx.x] = sum;
-
-        if (threadIdx.x < 16)
-        {
-            v_sum[threadIdx.x] = sum += v_sum[threadIdx.x + 16];
-            v_sum[threadIdx.x] = sum += v_sum[threadIdx.x + 8];
-            v_sum[threadIdx.x] = sum += v_sum[threadIdx.x + 4];
-            v_sum[threadIdx.x] = sum += v_sum[threadIdx.x + 2];
-            v_sum[threadIdx.x] = sum += v_sum[threadIdx.x + 1];
-        }
-    }
-
     __global__ void icvCalcOrientation(const float* featureX, const float* featureY, const float* featureSize, float* featureDir)
     {        
         #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
@@ -599,8 +566,8 @@ namespace cv { namespace gpu { namespace surf
 
                 float* s_sum_row = s_sum + threadIdx.y * 32;
 
-                reduceSum32(s_sum_row, sumx);
-                reduceSum32(s_sum_row, sumy);
+                warpReduce32(s_sum_row, sumx, threadIdx.x, plus<volatile float>());
+                warpReduce32(s_sum_row, sumy, threadIdx.x, plus<volatile float>());
 
                 const float temp_mod = sumx * sumx + sumy * sumy;
                 if (temp_mod > best_mod)
diff --git a/modules/gpu/src/element_operations.cpp b/modules/gpu/src/element_operations.cpp
index 7123a83ff7..640bae71df 100644
--- a/modules/gpu/src/element_operations.cpp
+++ b/modules/gpu/src/element_operations.cpp
@@ -68,6 +68,8 @@ void cv::gpu::max(const GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_nogpu(
 void cv::gpu::max(const GpuMat&, double, GpuMat&, Stream&) { throw_nogpu(); }
 double cv::gpu::threshold(const GpuMat&, GpuMat&, double, double, int, Stream&) {throw_nogpu(); return 0.0;}
 
+void cv::gpu::pow(const GpuMat&, double, GpuMat&, Stream&)  { throw_nogpu(); }
+
 #else
 
 ////////////////////////////////////////////////////////////////////////
@@ -96,16 +98,20 @@ namespace
         switch (src1.type())
         {
         case CV_8UC1:
-            nppSafeCall( npp_func_8uc1(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz, 0) );
+            nppSafeCall( npp_func_8uc1(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, 0) );
             break;
         case CV_8UC4:
-            nppSafeCall( npp_func_8uc4(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz, 0) );
+            nppSafeCall( npp_func_8uc4(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, 0) );
             break;
         case CV_32SC1:
-            nppSafeCall( npp_func_32sc1(src1.ptr<Npp32s>(), src1.step, src2.ptr<Npp32s>(), src2.step, dst.ptr<Npp32s>(), dst.step, sz) );
+            nppSafeCall( npp_func_32sc1(src1.ptr<Npp32s>(), static_cast<int>(src1.step), src2.ptr<Npp32s>(), static_cast<int>(src2.step), 
+                dst.ptr<Npp32s>(), static_cast<int>(dst.step), sz) );
             break;
         case CV_32FC1:
-            nppSafeCall( npp_func_32fc1(src1.ptr<Npp32f>(), src1.step, src2.ptr<Npp32f>(), src2.step, dst.ptr<Npp32f>(), dst.step, sz) );
+            nppSafeCall( npp_func_32fc1(src1.ptr<Npp32f>(), static_cast<int>(src1.step), src2.ptr<Npp32f>(), static_cast<int>(src2.step), 
+                dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
             break;
         default:
             CV_Assert(!"Unsupported source type");
@@ -139,7 +145,7 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<Npp32f>(), src.step, (Npp32f)sc[0], dst.ptr<Npp32f>(), dst.step, sz) );
+            nppSafeCall( func(src.ptr<Npp32f>(), static_cast<int>(src.step), (Npp32f)sc[0], dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -161,7 +167,7 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<Npp32fc>(), src.step, nValue, dst.ptr<Npp32fc>(), dst.step, sz) );
+            nppSafeCall( func(src.ptr<Npp32fc>(), static_cast<int>(src.step), nValue, dst.ptr<Npp32fc>(), static_cast<int>(dst.step), sz) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -174,9 +180,22 @@ void cv::gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& s
     nppArithmCaller(src1, src2, dst, nppiAdd_8u_C1RSfs, nppiAdd_8u_C4RSfs, nppiAdd_32s_C1R, nppiAdd_32f_C1R, StreamAccessor::getStream(stream));
 }
 
+namespace cv { namespace gpu { namespace mathfunc
+{
+    template <typename T>
+    void subtractCaller(const DevMem2D src1, const DevMem2D src2, DevMem2D dst, cudaStream_t stream);
+}}}
+
 void cv::gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream)
 {
-    nppArithmCaller(src2, src1, dst, nppiSub_8u_C1RSfs, nppiSub_8u_C4RSfs, nppiSub_32s_C1R, nppiSub_32f_C1R, StreamAccessor::getStream(stream));
+    if (src1.depth() == CV_16S && src2.depth() == CV_16S)
+    {
+        CV_Assert(src1.size() == src2.size());
+        dst.create(src1.size(), src1.type());
+        mathfunc::subtractCaller<short>(src1.reshape(1), src2.reshape(1), dst.reshape(1), StreamAccessor::getStream(stream));
+    }
+    else
+        nppArithmCaller(src2, src1, dst, nppiSub_8u_C1RSfs, nppiSub_8u_C4RSfs, nppiSub_32s_C1R, nppiSub_32f_C1R, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream)
@@ -211,22 +230,42 @@ void cv::gpu::subtract(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream&
 
 void cv::gpu::multiply(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
 {
-    typedef void (*caller_t)(const GpuMat& src, const Scalar& sc, GpuMat& dst, cudaStream_t stream);
-    static const caller_t callers[] = {0, NppArithmScalar<1, nppiMulC_32f_C1R>::calc, NppArithmScalar<2, nppiMulC_32fc_C1R>::calc};
+    CV_Assert(src.type() == CV_32FC1);
 
-    CV_Assert(src.type() == CV_32FC1 || src.type() == CV_32FC2);
+    dst.create(src.size(), src.type());
 
-    callers[src.channels()](src, sc, dst, StreamAccessor::getStream(stream));
+    NppiSize sz;
+    sz.width  = src.cols;
+    sz.height = src.rows;
+
+    cudaStream_t cudaStream = StreamAccessor::getStream(stream);
+
+    NppStreamHandler h(cudaStream);
+
+    nppSafeCall( nppiMulC_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step), (Npp32f)sc[0], dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
+
+    if (cudaStream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 }
 
 void cv::gpu::divide(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
 {
-    typedef void (*caller_t)(const GpuMat& src, const Scalar& sc, GpuMat& dst, cudaStream_t stream);
-    static const caller_t callers[] = {0, NppArithmScalar<1, nppiDivC_32f_C1R>::calc, NppArithmScalar<2, nppiDivC_32fc_C1R>::calc};
+    CV_Assert(src.type() == CV_32FC1);
 
-    CV_Assert(src.type() == CV_32FC1 || src.type() == CV_32FC2);
+    dst.create(src.size(), src.type());
 
-    callers[src.channels()](src, sc, dst, StreamAccessor::getStream(stream));
+    NppiSize sz;
+    sz.width  = src.cols;
+    sz.height = src.rows;
+
+    cudaStream_t cudaStream = StreamAccessor::getStream(stream);
+
+    NppStreamHandler h(cudaStream);
+
+    nppSafeCall( nppiDivC_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step), (Npp32f)sc[0], dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
+
+    if (cudaStream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
 }
 
 
@@ -252,16 +291,20 @@ void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Strea
     switch (src1.type())
     {
     case CV_8UC1:
-        nppSafeCall( nppiAbsDiff_8u_C1R(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_8u_C1R(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
         break;
     case CV_8UC4:
-        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, dst.ptr<Npp8u>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
         break;
     case CV_32SC1:
-        nppSafeCall( nppiAbsDiff_32s_C1R(src1.ptr<Npp32s>(), src1.step, src2.ptr<Npp32s>(), src2.step, dst.ptr<Npp32s>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_32s_C1R(src1.ptr<Npp32s>(), static_cast<int>(src1.step), src2.ptr<Npp32s>(), static_cast<int>(src2.step), 
+            dst.ptr<Npp32s>(), static_cast<int>(dst.step), sz) );
         break;
     case CV_32FC1:
-        nppSafeCall( nppiAbsDiff_32f_C1R(src1.ptr<Npp32f>(), src1.step, src2.ptr<Npp32f>(), src2.step, dst.ptr<Npp32f>(), dst.step, sz) );
+        nppSafeCall( nppiAbsDiff_32f_C1R(src1.ptr<Npp32f>(), static_cast<int>(src1.step), src2.ptr<Npp32f>(), static_cast<int>(src2.step), 
+            dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz) );
         break;
     default:
         CV_Assert(!"Unsupported source type");
@@ -285,7 +328,7 @@ void cv::gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst, Strea
 
     NppStreamHandler h(stream);
 
-    nppSafeCall( nppiAbsDiffC_32f_C1R(src1.ptr<Npp32f>(), src1.step, dst.ptr<Npp32f>(), dst.step, sz, (Npp32f)src2[0]) );
+    nppSafeCall( nppiAbsDiffC_32f_C1R(src1.ptr<Npp32f>(), static_cast<int>(src1.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz, (Npp32f)src2[0]) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -323,9 +366,9 @@ void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int c
         {
             NppStreamHandler h(stream);
 
-            nppSafeCall( nppiCompare_8u_C4R(src1.ptr<Npp8u>(), src1.step,
-                src2.ptr<Npp8u>(), src2.step,
-                dst.ptr<Npp8u>(), dst.step, sz, nppCmpOp[cmpop]) );
+            nppSafeCall( nppiCompare_8u_C4R(src1.ptr<Npp8u>(), static_cast<int>(src1.step),
+                src2.ptr<Npp8u>(), static_cast<int>(src2.step),
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, nppCmpOp[cmpop]) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -341,9 +384,9 @@ void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int c
         {
             NppStreamHandler h(stream);
 
-            nppSafeCall( nppiCompare_32f_C1R(src1.ptr<Npp32f>(), src1.step,
-                src2.ptr<Npp32f>(), src2.step,
-                dst.ptr<Npp8u>(), dst.step, sz, nppCmpOp[cmpop]) );
+            nppSafeCall( nppiCompare_32f_C1R(src1.ptr<Npp32f>(), static_cast<int>(src1.step),
+                src2.ptr<Npp32f>(), static_cast<int>(src2.step),
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, nppCmpOp[cmpop]) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -361,7 +404,7 @@ void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int c
 
 namespace cv { namespace gpu { namespace mathfunc
 {
-    void bitwiseNotCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src, PtrStep dst, cudaStream_t stream);
+    void bitwiseNotCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src, PtrStep dst, cudaStream_t stream);
 
     template <typename T>
     void bitwiseMaskNotCaller(int rows, int cols, int cn, const PtrStep src, const PtrStep mask, PtrStep dst, cudaStream_t stream);
@@ -415,17 +458,17 @@ void cv::gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, St
 
 namespace cv { namespace gpu { namespace mathfunc
 {
-    void bitwiseOrCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
+    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
 
     template <typename T>
     void bitwiseMaskOrCaller(int rows, int cols, int cn, const PtrStep src1, const PtrStep src2, const PtrStep mask, PtrStep dst, cudaStream_t stream);
 
-    void bitwiseAndCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
+    void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
 
     template <typename T>
     void bitwiseMaskAndCaller(int rows, int cols, int cn, const PtrStep src1, const PtrStep src2, const PtrStep mask, PtrStep dst, cudaStream_t stream);
 
-    void bitwiseXorCaller(int rows, int cols, int elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
+    void bitwiseXorCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStep src1, const PtrStep src2, PtrStep dst, cudaStream_t stream);
 
     template <typename T>
     void bitwiseMaskXorCaller(int rows, int cols, int cn, const PtrStep src1, const PtrStep src2, const PtrStep mask, PtrStep dst, cudaStream_t stream);
@@ -697,8 +740,8 @@ double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double
         sz.width  = src.cols;
         sz.height = src.rows;
 
-        nppSafeCall( nppiThreshold_32f_C1R(src.ptr<Npp32f>(), src.step,
-            dst.ptr<Npp32f>(), dst.step, sz, static_cast<Npp32f>(thresh), NPP_CMP_GREATER) );
+        nppSafeCall( nppiThreshold_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step),
+            dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz, static_cast<Npp32f>(thresh), NPP_CMP_GREATER) );
 
         if (stream == 0)
             cudaSafeCall( cudaDeviceSynchronize() );
@@ -735,4 +778,36 @@ double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double
     return thresh;
 }
 
-#endif
\ No newline at end of file
+////////////////////////////////////////////////////////////////////////
+// pow
+
+namespace cv
+{
+    namespace gpu
+    {
+        namespace mathfunc
+        {
+            template<typename T>
+            void pow_caller(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+        }
+    }
+}
+
+void cv::gpu::pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream)
+{    
+    CV_Assert( src.depth() != CV_64F );
+    dst.create(src.size(), src.type());
+
+    typedef void (*caller_t)(const DevMem2D& src, float power, DevMem2D dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
+    {
+        mathfunc::pow_caller<unsigned char>,  mathfunc::pow_caller<signed char>, 
+        mathfunc::pow_caller<unsigned short>, mathfunc::pow_caller<short>, 
+        mathfunc::pow_caller<int>, mathfunc::pow_caller<float>
+    };
+
+    callers[src.depth()](src.reshape(1), (float)power, dst.reshape(1), StreamAccessor::getStream(stream));    
+}
+
+#endif
diff --git a/modules/gpu/src/error.cpp b/modules/gpu/src/error.cpp
index 0ca918d521..1f38f6174c 100644
--- a/modules/gpu/src/error.cpp
+++ b/modules/gpu/src/error.cpp
@@ -110,7 +110,7 @@ namespace
         error_entry( NPP_ODD_ROI_WARNING )
     };
 
-    int error_num = sizeof(npp_errors)/sizeof(npp_errors[0]);
+    const size_t error_num = sizeof(npp_errors) / sizeof(npp_errors[0]);
 
     struct Searcher
     {
@@ -161,7 +161,7 @@ namespace cv
     {
         const string getNppErrorString( int err )
         {
-            int idx = std::find_if(npp_errors, npp_errors + error_num, Searcher(err)) - npp_errors;
+            size_t idx = std::find_if(npp_errors, npp_errors + error_num, Searcher(err)) - npp_errors;
             const string& msg = (idx != error_num) ? npp_errors[idx].str : string("Unknown error code");
 
             std::stringstream interpreter;
diff --git a/modules/gpu/src/filtering.cpp b/modules/gpu/src/filtering.cpp
index 61e15e2739..2d1a934101 100644
--- a/modules/gpu/src/filtering.cpp
+++ b/modules/gpu/src/filtering.cpp
@@ -192,7 +192,8 @@ namespace
             Size src_size = src.size();
 
             dst.create(src_size, dstType);
-            dstBuf.create(src_size, bufType);
+
+            ensureSizeIsEnough(src_size, bufType, dstBuf);
 
             if (stream)
             {
@@ -252,7 +253,8 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( nppiSumWindowRow_8u32f_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp32f>(), dst.step, sz, ksize, anchor) );
+            nppSafeCall( nppiSumWindowRow_8u32f_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+                dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz, ksize, anchor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -286,7 +288,8 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( nppiSumWindowColumn_8u32f_C1R(src.ptr<Npp8u>(), src.step, dst.ptr<Npp32f>(), dst.step, sz, ksize, anchor) );
+            nppSafeCall( nppiSumWindowColumn_8u32f_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+                dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz, ksize, anchor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -332,7 +335,8 @@ namespace
 
             NppStreamHandler h(stream);
             
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, oKernelSize, oAnchor) );
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, oKernelSize, oAnchor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -400,7 +404,8 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, kernel.ptr<Npp8u>(), oKernelSize, oAnchor) );
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), 
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, kernel.ptr<Npp8u>(), oKernelSize, oAnchor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -583,7 +588,7 @@ namespace
 
             NppStreamHandler h(stream);
                                   
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, 
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, 
                 kernel.ptr<Npp32s>(), oKernelSize, oAnchor, nDivisor) );
 
             if (stream == 0)
@@ -665,7 +670,8 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, kernel.ptr<Npp32s>(), ksize, anchor, nDivisor) );
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, 
+                kernel.ptr<Npp32s>(), ksize, anchor, nDivisor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -717,7 +723,7 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
     CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
 
     CV_Assert(srcType == CV_8UC1 || srcType == CV_8UC4 || srcType == CV_16SC1 || srcType == CV_16SC2 
-        || srcType == CV_32SC1 || srcType == CV_32FC1);
+        || srcType == CV_16SC3 || srcType == CV_32SC1 || srcType == CV_32FC1);
 
     CV_Assert(CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(srcType) == CV_MAT_CN(bufType));
 
@@ -747,6 +753,9 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
     case CV_16SC2:
         func = filters::linearRowFilter_gpu<short2, float2>;
         break;
+    case CV_16SC3:
+        func = filters::linearRowFilter_gpu<short3, float3>;
+        break;
     case CV_32SC1:
         func = filters::linearRowFilter_gpu<int, float>;
         break;
@@ -776,7 +785,8 @@ namespace
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, kernel.ptr<Npp32s>(), ksize, anchor, nDivisor) );
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, 
+                kernel.ptr<Npp32s>(), ksize, anchor, nDivisor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -827,8 +837,8 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
     int gpuBorderType;
     CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
    
-    CV_Assert(dstType == CV_8UC1 || dstType == CV_8UC4 || dstType == CV_16SC1 || dstType == CV_16SC2 
-        || dstType == CV_32SC1 || dstType == CV_32FC1);
+    CV_Assert(dstType == CV_8UC1 || dstType == CV_8UC4 || dstType == CV_16SC1 || dstType == CV_16SC2
+        || dstType == CV_16SC3 || dstType == CV_32SC1 || dstType == CV_32FC1);
 
     CV_Assert(CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(dstType) == CV_MAT_CN(bufType));
 
@@ -858,6 +868,9 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
     case CV_16SC2:
         func = filters::linearColumnFilter_gpu<float2, short2>;
         break;
+    case CV_16SC3:
+        func = filters::linearColumnFilter_gpu<float3, short3>;
+        break;
     case CV_32SC1:
         func = filters::linearColumnFilter_gpu<float, int>;
         break;
@@ -1033,7 +1046,7 @@ namespace
 
             NppStreamHandler h(stream);
             
-            nppSafeCall( func(src.ptr<Npp8u>(), src.step, dst.ptr<Npp8u>(), dst.step, sz, oKernelSize, oAnchor) );
+            nppSafeCall( func(src.ptr<Npp8u>(), static_cast<int>(src.step), dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz, oKernelSize, oAnchor) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/gpumat.cpp b/modules/gpu/src/gpumat.cpp
new file mode 100644
index 0000000000..ca4b147a40
--- /dev/null
+++ b/modules/gpu/src/gpumat.cpp
@@ -0,0 +1,911 @@
+/*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*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::gpu;
+
+////////////////////////////////////////////////////////////////////////
+//////////////////////////////// GpuMat ////////////////////////////////
+////////////////////////////////////////////////////////////////////////
+
+cv::gpu::GpuMat::GpuMat(Size size_, int type_) : 
+    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+{
+    if (size_.height > 0 && size_.width > 0)
+        create(size_.height, size_.width, type_);
+}
+
+cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, const Scalar& s_) : 
+    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+{
+    if (rows_ > 0 && cols_ > 0)
+    {
+        create(rows_, cols_, type_);
+        *this = s_;
+    }
+}
+
+cv::gpu::GpuMat::GpuMat(Size size_, int type_, const Scalar& s_) : 
+    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
+{
+    if (size_.height > 0 && size_.width > 0)
+    {
+        create(size_.height, size_.width, type_);
+        *this = s_;
+    }
+}
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m) : 
+    flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend)
+{
+    if (refcount)
+        CV_XADD(refcount, 1);
+}
+
+cv::gpu::GpuMat::GpuMat(int rows_, int cols_, int type_, void* data_, size_t step_) : 
+    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(rows_), cols(cols_), step(step_), data((uchar*)data_), refcount(0),
+    datastart((uchar*)data_), dataend((uchar*)data_)
+{
+    size_t minstep = cols * elemSize();
+    if (step == Mat::AUTO_STEP)
+    {
+        step = minstep;
+        flags |= Mat::CONTINUOUS_FLAG;
+    }
+    else
+    {
+        if (rows == 1) step = minstep;
+        CV_DbgAssert( step >= minstep );
+        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
+    }
+    dataend += step * (rows - 1) + minstep;
+}
+
+cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) : 
+    flags(Mat::MAGIC_VAL + (type_ & TYPE_MASK)), rows(size_.height), cols(size_.width),
+    step(step_), data((uchar*)data_), refcount(0),
+    datastart((uchar*)data_), dataend((uchar*)data_)
+{
+    size_t minstep = cols * elemSize();
+    if (step == Mat::AUTO_STEP)
+    {
+        step = minstep;
+        flags |= Mat::CONTINUOUS_FLAG;
+    }
+    else
+    {
+        if (rows == 1) step = minstep;
+        CV_DbgAssert( step >= minstep );
+        flags |= step == minstep ? Mat::CONTINUOUS_FLAG : 0;
+    }
+    dataend += step * (rows - 1) + minstep;
+}
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange)
+{
+    flags = m.flags;
+    step = m.step; refcount = m.refcount;
+    data = m.data; datastart = m.datastart; dataend = m.dataend;
+
+    if (rowRange == Range::all())
+        rows = m.rows;
+    else
+    {
+        CV_Assert( 0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows );
+        rows = rowRange.size();
+        data += step*rowRange.start;
+    }
+
+    if (colRange == Range::all())
+        cols = m.cols;
+    else
+    {
+        CV_Assert( 0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols );
+        cols = colRange.size();
+        data += colRange.start*elemSize();
+        flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
+    }
+
+    if( rows == 1 )
+        flags |= Mat::CONTINUOUS_FLAG;
+
+    if( refcount )
+        CV_XADD(refcount, 1);
+    if( rows <= 0 || cols <= 0 )
+        rows = cols = 0;
+}
+
+cv::gpu::GpuMat::GpuMat(const GpuMat& m, const Rect& roi) : 
+    flags(m.flags), rows(roi.height), cols(roi.width),
+    step(m.step), data(m.data + roi.y*step), refcount(m.refcount),
+    datastart(m.datastart), dataend(m.dataend)
+{
+    flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
+    data += roi.x*elemSize();
+    CV_Assert( 0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.cols &&
+        0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.rows );
+    if( refcount )
+        CV_XADD(refcount, 1);
+    if( rows <= 0 || cols <= 0 )
+        rows = cols = 0;
+}
+
+cv::gpu::GpuMat::GpuMat(const Mat& m) : 
+    flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
+{ 
+    upload(m); 
+}
+
+GpuMat& cv::gpu::GpuMat::operator = (const GpuMat& m)
+{
+    if( this != &m )
+    {
+        if( m.refcount )
+            CV_XADD(m.refcount, 1);
+        release();
+        flags = m.flags;
+        rows = m.rows; cols = m.cols;
+        step = m.step; data = m.data;
+        datastart = m.datastart; dataend = m.dataend;
+        refcount = m.refcount;
+    }
+    return *this;
+}
+
+GpuMat& cv::gpu::GpuMat::operator = (const Mat& m) 
+{ 
+    upload(m); return *this; 
+}
+
+cv::gpu::GpuMat::operator Mat() const
+{
+    Mat m;
+    download(m);
+    return m;
+}
+
+GpuMat cv::gpu::GpuMat::row(int y) const 
+{ 
+    return GpuMat(*this, Range(y, y+1), Range::all()); 
+}
+
+GpuMat cv::gpu::GpuMat::col(int x) const 
+{ 
+    return GpuMat(*this, Range::all(), Range(x, x+1)); 
+}
+
+GpuMat cv::gpu::GpuMat::rowRange(int startrow, int endrow) const 
+{ 
+    return GpuMat(*this, Range(startrow, endrow), Range::all()); 
+}
+
+GpuMat cv::gpu::GpuMat::rowRange(const Range& r) const 
+{ 
+    return GpuMat(*this, r, Range::all()); 
+}
+
+GpuMat cv::gpu::GpuMat::colRange(int startcol, int endcol) const 
+{ 
+    return GpuMat(*this, Range::all(), Range(startcol, endcol)); 
+}
+
+GpuMat cv::gpu::GpuMat::colRange(const Range& r) const 
+{ 
+    return GpuMat(*this, Range::all(), r); 
+}
+
+void cv::gpu::GpuMat::create(Size size_, int type_) 
+{ 
+    create(size_.height, size_.width, type_); 
+}
+
+void cv::gpu::GpuMat::swap(GpuMat& b)
+{
+    std::swap( flags, b.flags );
+    std::swap( rows, b.rows ); 
+    std::swap( cols, b.cols );
+    std::swap( step, b.step ); 
+    std::swap( data, b.data );
+    std::swap( datastart, b.datastart );
+    std::swap( dataend, b.dataend );
+    std::swap( refcount, b.refcount );
+}
+
+void cv::gpu::GpuMat::locateROI(Size& wholeSize, Point& ofs) const
+{
+    size_t esz = elemSize(), minstep;
+    ptrdiff_t delta1 = data - datastart, delta2 = dataend - datastart;
+    CV_DbgAssert( step > 0 );
+    if( delta1 == 0 )
+        ofs.x = ofs.y = 0;
+    else
+    {
+        ofs.y = (int)(delta1/step);
+        ofs.x = (int)((delta1 - step*ofs.y)/esz);
+        CV_DbgAssert( data == datastart + ofs.y*step + ofs.x*esz );
+    }
+    minstep = (ofs.x + cols)*esz;
+    wholeSize.height = (int)((delta2 - minstep)/step + 1);
+    wholeSize.height = std::max(wholeSize.height, ofs.y + rows);
+    wholeSize.width = (int)((delta2 - step*(wholeSize.height-1))/esz);
+    wholeSize.width = std::max(wholeSize.width, ofs.x + cols);
+}
+
+GpuMat& cv::gpu::GpuMat::adjustROI(int dtop, int dbottom, int dleft, int dright)
+{
+    Size wholeSize; Point ofs;
+    size_t esz = elemSize();
+    locateROI( wholeSize, ofs );
+    int row1 = std::max(ofs.y - dtop, 0), row2 = std::min(ofs.y + rows + dbottom, wholeSize.height);
+    int col1 = std::max(ofs.x - dleft, 0), col2 = std::min(ofs.x + cols + dright, wholeSize.width);
+    data += (row1 - ofs.y)*step + (col1 - ofs.x)*esz;
+    rows = row2 - row1; cols = col2 - col1;
+    if( esz*cols == step || rows == 1 )
+        flags |= Mat::CONTINUOUS_FLAG;
+    else
+        flags &= ~Mat::CONTINUOUS_FLAG;
+    return *this;
+}
+
+cv::gpu::GpuMat GpuMat::operator()(Range rowRange, Range colRange) const 
+{ 
+    return GpuMat(*this, rowRange, colRange); 
+}
+
+cv::gpu::GpuMat GpuMat::operator()(const Rect& roi) const 
+{ 
+    return GpuMat(*this, roi); 
+}
+
+bool cv::gpu::GpuMat::isContinuous() const 
+{ 
+    return (flags & Mat::CONTINUOUS_FLAG) != 0; 
+}
+
+size_t cv::gpu::GpuMat::elemSize() const 
+{ 
+    return CV_ELEM_SIZE(flags); 
+}
+
+size_t cv::gpu::GpuMat::elemSize1() const 
+{ 
+    return CV_ELEM_SIZE1(flags); 
+}
+
+int cv::gpu::GpuMat::type() const 
+{ 
+    return CV_MAT_TYPE(flags); 
+}
+
+int cv::gpu::GpuMat::depth() const 
+{ 
+    return CV_MAT_DEPTH(flags); 
+}
+
+int cv::gpu::GpuMat::channels() const 
+{ 
+    return CV_MAT_CN(flags); 
+}
+
+Size cv::gpu::GpuMat::size() const 
+{ 
+    return Size(cols, rows); 
+}
+
+unsigned char* cv::gpu::GpuMat::ptr(int y)
+{
+    CV_DbgAssert( (unsigned)y < (unsigned)rows );
+    return data + step*y;
+}
+
+const unsigned char* cv::gpu::GpuMat::ptr(int y) const
+{
+    CV_DbgAssert( (unsigned)y < (unsigned)rows );
+    return data + step*y;
+}
+
+GpuMat cv::gpu::GpuMat::t() const
+{
+    GpuMat tmp;
+    transpose(*this, tmp);
+    return tmp;
+}
+
+GpuMat cv::gpu::createContinuous(int rows, int cols, int type)
+{
+    GpuMat m;
+    createContinuous(rows, cols, type, m);
+    return m;
+}
+
+void cv::gpu::createContinuous(Size size, int type, GpuMat& m)
+{
+    createContinuous(size.height, size.width, type, m);
+}
+
+GpuMat cv::gpu::createContinuous(Size size, int type)
+{
+    GpuMat m;
+    createContinuous(size, type, m);
+    return m;
+}
+
+void cv::gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m)
+{
+    ensureSizeIsEnough(size.height, size.width, type, m);
+}
+
+#if !defined (HAVE_CUDA)
+
+void cv::gpu::GpuMat::upload(const Mat&) { throw_nogpu(); }
+void cv::gpu::GpuMat::download(cv::Mat&) const { throw_nogpu(); }
+void cv::gpu::GpuMat::copyTo(GpuMat&) const { throw_nogpu(); }
+void cv::gpu::GpuMat::copyTo(GpuMat&, const GpuMat&) const { throw_nogpu(); }
+void cv::gpu::GpuMat::convertTo(GpuMat&, int, double, double) const { throw_nogpu(); }
+GpuMat& cv::gpu::GpuMat::operator = (const Scalar&) { throw_nogpu(); return *this; }
+GpuMat& cv::gpu::GpuMat::setTo(const Scalar&, const GpuMat&) { throw_nogpu(); return *this; }
+GpuMat cv::gpu::GpuMat::reshape(int, int) const { throw_nogpu(); return GpuMat(); }
+void cv::gpu::GpuMat::create(int, int, int) { throw_nogpu(); }
+void cv::gpu::GpuMat::release() {}
+void cv::gpu::createContinuous(int, int, int, GpuMat&) { throw_nogpu(); }
+void cv::gpu::ensureSizeIsEnough(int, int, int, GpuMat&) { throw_nogpu(); }
+
+#else /* !defined (HAVE_CUDA) */
+
+namespace cv { namespace gpu { namespace matrix_operations
+{
+    void copy_to_with_mask(const DevMem2D& src, DevMem2D dst, int depth, const DevMem2D& mask, int channels, const cudaStream_t & stream = 0);
+
+    template <typename T>
+    void set_to_gpu(const DevMem2D& mat, const T* scalar, int channels, cudaStream_t stream);
+    template <typename T>
+    void set_to_gpu(const DevMem2D& mat, const T* scalar, const DevMem2D& mask, int channels, cudaStream_t stream);
+
+    void convert_gpu(const DevMem2D& src, int sdepth, const DevMem2D& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
+}}}
+
+
+void cv::gpu::GpuMat::upload(const Mat& m)
+{
+    CV_DbgAssert(!m.empty());
+    create(m.size(), m.type());
+    cudaSafeCall( cudaMemcpy2D(data, step, m.data, m.step, cols * elemSize(), rows, cudaMemcpyHostToDevice) );
+}
+
+void cv::gpu::GpuMat::upload(const CudaMem& m, Stream& stream)
+{
+    CV_DbgAssert(!m.empty());
+    stream.enqueueUpload(m, *this);
+}
+
+void cv::gpu::GpuMat::download(cv::Mat& m) const
+{
+    CV_DbgAssert(!this->empty());
+    m.create(size(), type());
+    cudaSafeCall( cudaMemcpy2D(m.data, m.step, data, step, cols * elemSize(), rows, cudaMemcpyDeviceToHost) );
+}
+
+void cv::gpu::GpuMat::download(CudaMem& m, Stream& stream) const
+{
+    CV_DbgAssert(!m.empty());
+    stream.enqueueDownload(*this, m);
+}
+
+void cv::gpu::GpuMat::copyTo(GpuMat& m) const
+{
+    CV_DbgAssert(!this->empty());
+    m.create(size(), type());
+    cudaSafeCall( cudaMemcpy2D(m.data, m.step, data, step, cols * elemSize(), rows, cudaMemcpyDeviceToDevice) );
+    cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+void cv::gpu::GpuMat::copyTo(GpuMat& mat, const GpuMat& mask) const
+{
+    if (mask.empty())
+    {
+        copyTo(mat);
+    }
+    else
+    {
+        mat.create(size(), type());
+        cv::gpu::matrix_operations::copy_to_with_mask(*this, mat, depth(), mask, channels());
+    }
+}
+
+namespace
+{
+    template<int n> struct NPPTypeTraits;
+    template<> struct NPPTypeTraits<CV_8U>  { typedef Npp8u npp_type; };
+    template<> struct NPPTypeTraits<CV_16U> { typedef Npp16u npp_type; };
+    template<> struct NPPTypeTraits<CV_16S> { typedef Npp16s npp_type; };
+    template<> struct NPPTypeTraits<CV_32S> { typedef Npp32s npp_type; };
+    template<> struct NPPTypeTraits<CV_32F> { typedef Npp32f npp_type; };
+
+    template<int SDEPTH, int DDEPTH> struct NppConvertFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        typedef NppStatus (*func_ptr)(const src_t* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI);
+    };
+    template<int DDEPTH> struct NppConvertFunc<CV_32F, DDEPTH>
+    {
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        typedef NppStatus (*func_ptr)(const Npp32f* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI, NppRoundMode eRoundMode);
+    };
+
+    template<int SDEPTH, int DDEPTH, typename NppConvertFunc<SDEPTH, DDEPTH>::func_ptr func> struct NppCvt
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        static void cvt(const GpuMat& src, GpuMat& dst)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int DDEPTH, typename NppConvertFunc<CV_32F, DDEPTH>::func_ptr func> struct NppCvt<CV_32F, DDEPTH, func>
+    {
+        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
+
+        static void cvt(const GpuMat& src, GpuMat& dst)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            nppSafeCall( func(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<dst_t>(), static_cast<int>(dst.step), sz, NPP_RND_NEAR) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    void convertToKernelCaller(const GpuMat& src, GpuMat& dst)
+    {
+        matrix_operations::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0);
+    }
+}
+
+void cv::gpu::GpuMat::convertTo( GpuMat& dst, int rtype, double alpha, double beta ) const
+{
+    CV_Assert((depth() != CV_64F && CV_MAT_DEPTH(rtype) != CV_64F) || 
+        (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE)));
+
+    bool noScale = fabs(alpha-1) < std::numeric_limits<double>::epsilon() && fabs(beta) < std::numeric_limits<double>::epsilon();
+
+    if( rtype < 0 )
+        rtype = type();
+    else
+        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), channels());
+
+    int scn = channels();
+    int sdepth = depth(), ddepth = CV_MAT_DEPTH(rtype);
+    if( sdepth == ddepth && noScale )
+    {
+        copyTo(dst);
+        return;
+    }
+
+    GpuMat temp;
+    const GpuMat* psrc = this;
+    if( sdepth != ddepth && psrc == &dst )
+        psrc = &(temp = *this);
+
+    dst.create( size(), rtype );
+
+    if (!noScale)
+        matrix_operations::convert_gpu(psrc->reshape(1), sdepth, dst.reshape(1), ddepth, alpha, beta);
+    else
+    {
+        typedef void (*convert_caller_t)(const GpuMat& src, GpuMat& dst);
+        static const convert_caller_t convert_callers[8][8][4] =
+        {
+            {
+                {0,0,0,0},
+                {convertToKernelCaller, convertToKernelCaller, convertToKernelCaller, convertToKernelCaller},
+                {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::cvt},
+                {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::cvt},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::cvt},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::cvt},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {NppCvt<CV_32F, CV_8U, nppiConvert_32f8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0}
+            },
+            {
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
+                {0,0,0,0},
+                {0,0,0,0}
+            },
+            {
+                {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}
+            }
+        };
+
+        convert_callers[sdepth][ddepth][scn-1](*psrc, dst);
+    }
+}
+
+GpuMat& GpuMat::operator = (const Scalar& s)
+{
+    setTo(s);
+    return *this;
+}
+
+namespace
+{
+    template<int SDEPTH, int SCN> struct NppSetFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
+    };
+    template<int SDEPTH> struct NppSetFunc<SDEPTH, 1>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
+    };
+
+    template<int SDEPTH, int SCN, typename NppSetFunc<SDEPTH, SCN>::func_ptr func> struct NppSet
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, const Scalar& s)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            Scalar_<src_t> nppS = s;
+            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int SDEPTH, typename NppSetFunc<SDEPTH, 1>::func_ptr func> struct NppSet<SDEPTH, 1, func>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, const Scalar& s)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            Scalar_<src_t> nppS = s;
+            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    template <typename T>
+    void kernelSet(GpuMat& src, const Scalar& s)
+    {
+        Scalar_<T> sf = s;
+        matrix_operations::set_to_gpu(src, sf.val, src.channels(), 0);
+    }
+
+    template<int SDEPTH, int SCN> struct NppSetMaskFunc
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
+    };
+    template<int SDEPTH> struct NppSetMaskFunc<SDEPTH, 1>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
+    };
+
+    template<int SDEPTH, int SCN, typename NppSetMaskFunc<SDEPTH, SCN>::func_ptr func> struct NppSetMask
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            Scalar_<src_t> nppS = s;
+            nppSafeCall( func(nppS.val, src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+    template<int SDEPTH, typename NppSetMaskFunc<SDEPTH, 1>::func_ptr func> struct NppSetMask<SDEPTH, 1, func>
+    {
+        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
+
+        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
+        {
+            NppiSize sz;
+            sz.width = src.cols;
+            sz.height = src.rows;
+            Scalar_<src_t> nppS = s;
+            nppSafeCall( func(nppS[0], src.ptr<src_t>(), static_cast<int>(src.step), sz, mask.ptr<Npp8u>(), static_cast<int>(mask.step)) );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
+    };
+
+    template <typename T>
+    void kernelSetMask(GpuMat& src, const Scalar& s, const GpuMat& mask)
+    {
+        Scalar_<T> sf = s;
+        matrix_operations::set_to_gpu(src, sf.val, mask, src.channels(), 0);
+    }
+}
+
+GpuMat& GpuMat::setTo(const Scalar& s, const GpuMat& mask)
+{
+    CV_Assert(mask.type() == CV_8UC1);
+
+    CV_Assert((depth() != CV_64F) || 
+        (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE)));
+
+    CV_DbgAssert(!this->empty());
+
+    NppiSize sz;
+    sz.width  = cols;
+    sz.height = rows;
+
+    if (mask.empty())
+    {
+        if (s[0] == 0.0 && s[1] == 0.0 && s[2] == 0.0 && s[3] == 0.0)
+        {
+            cudaSafeCall( cudaMemset2D(data, step, 0, cols * elemSize(), rows) );
+            return *this;
+        }
+        if (depth() == CV_8U)
+        {
+            int cn = channels();
+
+            if (cn == 1 || (cn == 2 && s[0] == s[1]) || (cn == 3 && s[0] == s[1] && s[0] == s[2]) || (cn == 4 && s[0] == s[1] && s[0] == s[2] && s[0] == s[3]))
+            {
+                int val = saturate_cast<uchar>(s[0]);
+                cudaSafeCall( cudaMemset2D(data, step, val, cols * elemSize(), rows) );
+                return *this;
+            }
+        }
+        typedef void (*set_caller_t)(GpuMat& src, const Scalar& s);
+        static const set_caller_t set_callers[8][4] =
+        {
+            {NppSet<CV_8U, 1, nppiSet_8u_C1R>::set,kernelSet<uchar>,kernelSet<uchar>,NppSet<CV_8U, 4, nppiSet_8u_C4R>::set},
+            {kernelSet<schar>,kernelSet<schar>,kernelSet<schar>,kernelSet<schar>},
+            {NppSet<CV_16U, 1, nppiSet_16u_C1R>::set,NppSet<CV_16U, 2, nppiSet_16u_C2R>::set,kernelSet<ushort>,NppSet<CV_16U, 4, nppiSet_16u_C4R>::set},
+            {NppSet<CV_16S, 1, nppiSet_16s_C1R>::set,NppSet<CV_16S, 2, nppiSet_16s_C2R>::set,kernelSet<short>,NppSet<CV_16S, 4, nppiSet_16s_C4R>::set},
+            {NppSet<CV_32S, 1, nppiSet_32s_C1R>::set,kernelSet<int>,kernelSet<int>,NppSet<CV_32S, 4, nppiSet_32s_C4R>::set},
+            {NppSet<CV_32F, 1, nppiSet_32f_C1R>::set,kernelSet<float>,kernelSet<float>,NppSet<CV_32F, 4, nppiSet_32f_C4R>::set},
+            {kernelSet<double>,kernelSet<double>,kernelSet<double>,kernelSet<double>},
+            {0,0,0,0}
+        };
+        set_callers[depth()][channels()-1](*this, s);
+    }
+    else
+    {
+        typedef void (*set_caller_t)(GpuMat& src, const Scalar& s, const GpuMat& mask);
+        static const set_caller_t set_callers[8][4] =
+        {
+            {NppSetMask<CV_8U, 1, nppiSet_8u_C1MR>::set,kernelSetMask<uchar>,kernelSetMask<uchar>,NppSetMask<CV_8U, 4, nppiSet_8u_C4MR>::set},
+            {kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>},
+            {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::set,kernelSetMask<ushort>,kernelSetMask<ushort>,NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::set},
+            {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::set,kernelSetMask<short>,kernelSetMask<short>,NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::set},
+            {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::set,kernelSetMask<int>,kernelSetMask<int>,NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::set},
+            {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::set,kernelSetMask<float>,kernelSetMask<float>,NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::set},
+            {kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>},
+            {0,0,0,0}
+        };
+        set_callers[depth()][channels()-1](*this, s, mask);
+    }
+
+    return *this;
+}
+
+
+GpuMat cv::gpu::GpuMat::reshape(int new_cn, int new_rows) const
+{
+    GpuMat hdr = *this;
+
+    int cn = channels();
+    if( new_cn == 0 )
+        new_cn = cn;
+
+    int total_width = cols * cn;
+
+    if( (new_cn > total_width || total_width % new_cn != 0) && new_rows == 0 )
+        new_rows = rows * total_width / new_cn;
+
+    if( new_rows != 0 && new_rows != rows )
+    {
+        int total_size = total_width * rows;
+        if( !isContinuous() )
+            CV_Error( CV_BadStep, "The matrix is not continuous, thus its number of rows can not be changed" );
+
+        if( (unsigned)new_rows > (unsigned)total_size )
+            CV_Error( CV_StsOutOfRange, "Bad new number of rows" );
+
+        total_width = total_size / new_rows;
+
+        if( total_width * new_rows != total_size )
+            CV_Error( CV_StsBadArg, "The total number of matrix elements is not divisible by the new number of rows" );
+
+        hdr.rows = new_rows;
+        hdr.step = total_width * elemSize1();
+    }
+
+    int new_width = total_width / new_cn;
+
+    if( new_width * new_cn != total_width )
+        CV_Error( CV_BadNumChannels, "The total width is not divisible by the new number of channels" );
+
+    hdr.cols = new_width;
+    hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn-1) << CV_CN_SHIFT);
+    return hdr;
+}
+
+void cv::gpu::GpuMat::create(int _rows, int _cols, int _type)
+{
+    _type &= TYPE_MASK;
+    if( rows == _rows && cols == _cols && type() == _type && data )
+        return;
+    if( data )
+        release();
+    CV_DbgAssert( _rows >= 0 && _cols >= 0 );
+    if( _rows > 0 && _cols > 0 )
+    {
+        flags = Mat::MAGIC_VAL + _type;
+        rows = _rows;
+        cols = _cols;
+
+        size_t esz = elemSize();
+
+        void *dev_ptr;
+        cudaSafeCall( cudaMallocPitch(&dev_ptr, &step, esz * cols, rows) );
+
+        // Single row must be continuous
+        if (rows == 1)
+            step = esz * cols;
+
+        if (esz * cols == step)
+            flags |= Mat::CONTINUOUS_FLAG;
+
+        int64 _nettosize = (int64)step*rows;
+        size_t nettosize = (size_t)_nettosize;
+
+        datastart = data = (uchar*)dev_ptr;
+        dataend = data + nettosize;
+
+        refcount = (int*)fastMalloc(sizeof(*refcount));
+        *refcount = 1;
+    }
+}
+
+void cv::gpu::GpuMat::release()
+{
+    if( refcount && CV_XADD(refcount, -1) == 1 )
+    {
+        fastFree(refcount);
+        cudaSafeCall( cudaFree(datastart) );
+    }
+    data = datastart = dataend = 0;
+    step = rows = cols = 0;
+    refcount = 0;
+}
+
+void cv::gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
+{
+    int area = rows * cols;
+    if (!m.isContinuous() || m.type() != type || m.size().area() != area)
+        m.create(1, area, type);
+    m = m.reshape(0, rows);
+}
+
+void cv::gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
+{
+    if (m.type() == type && m.rows >= rows && m.cols >= cols)
+        m = m(Rect(0, 0, cols, rows));
+    else
+        m.create(rows, cols, type);
+}
+
+#endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/src/graphcuts.cpp b/modules/gpu/src/graphcuts.cpp
index 00f734b717..f3c4a06e2d 100644
--- a/modules/gpu/src/graphcuts.cpp
+++ b/modules/gpu/src/graphcuts.cpp
@@ -78,7 +78,7 @@ void cv::gpu::graphcut(GpuMat& terminals, GpuMat& leftTransp, GpuMat& rightTrans
     NppStreamHandler h(stream);
 
     nppSafeCall( nppiGraphcut_32s8u(terminals.ptr<Npp32s>(), leftTransp.ptr<Npp32s>(), rightTransp.ptr<Npp32s>(), top.ptr<Npp32s>(), bottom.ptr<Npp32s>(),
-        terminals.step, leftTransp.step, sznpp, labels.ptr<Npp8u>(), labels.step, buf.ptr<Npp8u>()) );
+        static_cast<int>(terminals.step), static_cast<int>(leftTransp.step), sznpp, labels.ptr<Npp8u>(), static_cast<int>(labels.step), buf.ptr<Npp8u>()) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/hog.cpp b/modules/gpu/src/hog.cpp
index 5aec63031e..09797f7dfd 100644
--- a/modules/gpu/src/hog.cpp
+++ b/modules/gpu/src/hog.cpp
@@ -218,7 +218,7 @@ void cv::gpu::HOGDescriptor::computeBlockHistograms(const GpuMat& img)
     Size blocks_per_img = numPartsWithin(img.size(), block_size, block_stride);
 
 	//   block_hists.create(1, block_hist_size * blocks_per_img.area(), CV_32F);
-	block_hists = getBuffer(1, block_hist_size * blocks_per_img.area(), CV_32F, block_hists_buf);
+	block_hists = getBuffer(1, static_cast<int>(block_hist_size * blocks_per_img.area()), CV_32F, block_hists_buf);
     
     hog::compute_hists(nbins, block_stride.width, block_stride.height, img.rows, img.cols, 
 						grad, qangle, (float)getWinSigma(), block_hists.ptr<float>());
@@ -234,11 +234,11 @@ void cv::gpu::HOGDescriptor::getDescriptors(const GpuMat& img, Size win_stride,
 
     computeBlockHistograms(img);
 
-    const int block_hist_size = getBlockHistogramSize();
+    const size_t block_hist_size = getBlockHistogramSize();
     Size blocks_per_win = numPartsWithin(win_size, block_size, block_stride);
     Size wins_per_img   = numPartsWithin(img.size(), win_size, win_stride);
 
-    descriptors.create(wins_per_img.area(), blocks_per_win.area() * block_hist_size, CV_32F);
+    descriptors.create(wins_per_img.area(), static_cast<int>(blocks_per_win.area() * block_hist_size), CV_32F);
 
     switch (descr_format)
     {
diff --git a/modules/gpu/src/imgproc_gpu.cpp b/modules/gpu/src/imgproc.cpp
similarity index 65%
rename from modules/gpu/src/imgproc_gpu.cpp
rename to modules/gpu/src/imgproc.cpp
index 38a2c35201..de35c39217 100644
--- a/modules/gpu/src/imgproc_gpu.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -56,6 +56,9 @@ void cv::gpu::resize(const GpuMat&, GpuMat&, Size, double, double, int, Stream&)
 void cv::gpu::copyMakeBorder(const GpuMat&, GpuMat&, int, int, int, int, const Scalar&, Stream&) { throw_nogpu(); }
 void cv::gpu::warpAffine(const GpuMat&, GpuMat&, const Mat&, Size, int, Stream&) { throw_nogpu(); }
 void cv::gpu::warpPerspective(const GpuMat&, GpuMat&, const Mat&, Size, int, Stream&) { throw_nogpu(); }
+void cv::gpu::buildWarpPlaneMaps(Size, Rect, const Mat&, double, double, double, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::buildWarpCylindricalMaps(Size, Rect, const Mat&, double, double, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::buildWarpSphericalMaps(Size, Rect, const Mat&, double, double, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::rotate(const GpuMat&, GpuMat&, Size, double, double, double, int, Stream&) { throw_nogpu(); }
 void cv::gpu::integral(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::integralBuffered(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
@@ -65,19 +68,43 @@ void cv::gpu::columnSum(const GpuMat&, GpuMat&) { throw_nogpu(); }
 void cv::gpu::rectStdDev(const GpuMat&, const GpuMat&, GpuMat&, const Rect&, Stream&) { throw_nogpu(); }
 void cv::gpu::evenLevels(GpuMat&, int, int, int) { throw_nogpu(); }
 void cv::gpu::histEven(const GpuMat&, GpuMat&, int, int, int, Stream&) { throw_nogpu(); }
+void cv::gpu::histEven(const GpuMat&, GpuMat&, GpuMat&, int, int, int, Stream&) { throw_nogpu(); }
 void cv::gpu::histEven(const GpuMat&, GpuMat*, int*, int*, int*, Stream&) { throw_nogpu(); }
+void cv::gpu::histEven(const GpuMat&, GpuMat*, GpuMat&, int*, int*, int*, Stream&) { throw_nogpu(); }
 void cv::gpu::histRange(const GpuMat&, GpuMat&, const GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::histRange(const GpuMat&, GpuMat&, const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::histRange(const GpuMat&, GpuMat*, const GpuMat*, Stream&) { throw_nogpu(); }
+void cv::gpu::histRange(const GpuMat&, GpuMat*, const GpuMat*, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::calcHist(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::calcHist(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::cornerHarris(const GpuMat&, GpuMat&, int, int, double, int) { throw_nogpu(); }
+void cv::gpu::cornerHarris(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, int, double, int) { throw_nogpu(); }
 void cv::gpu::cornerMinEigenVal(const GpuMat&, GpuMat&, int, int, int) { throw_nogpu(); }
+void cv::gpu::cornerMinEigenVal(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, int, int) { throw_nogpu(); }
 void cv::gpu::mulSpectrums(const GpuMat&, const GpuMat&, GpuMat&, int, bool) { throw_nogpu(); }
 void cv::gpu::mulAndScaleSpectrums(const GpuMat&, const GpuMat&, GpuMat&, int, float, bool) { throw_nogpu(); }
 void cv::gpu::dft(const GpuMat&, GpuMat&, Size, int) { throw_nogpu(); }
 void cv::gpu::ConvolveBuf::create(Size, Size) { throw_nogpu(); }
 void cv::gpu::convolve(const GpuMat&, const GpuMat&, GpuMat&, bool) { throw_nogpu(); }
 void cv::gpu::convolve(const GpuMat&, const GpuMat&, GpuMat&, bool, ConvolveBuf&) { throw_nogpu(); }
-void cv::gpu::downsample(const GpuMat&, GpuMat&, int) { throw_nogpu(); }
-
+void cv::gpu::downsample(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::upsample(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::pyrDown(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::PyrDownBuf::create(Size, int) { throw_nogpu(); }
+void cv::gpu::pyrDown(const GpuMat&, GpuMat&, PyrDownBuf&, Stream&) { throw_nogpu(); }
+void cv::gpu::pyrUp(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+void cv::gpu::PyrUpBuf::create(Size, int) { throw_nogpu(); }
+void cv::gpu::pyrUp(const GpuMat&, GpuMat&, PyrUpBuf&, Stream&) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, GpuMat&, double, double, int, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, CannyBuf&, GpuMat&, double, double, int, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, const GpuMat&, GpuMat&, double, double, bool) { throw_nogpu(); }
+void cv::gpu::Canny(const GpuMat&, const GpuMat&, CannyBuf&, GpuMat&, double, double, bool) { throw_nogpu(); }
+cv::gpu::CannyBuf::CannyBuf(const GpuMat&, const GpuMat&) { throw_nogpu(); }
+void cv::gpu::CannyBuf::create(const Size&, int) { throw_nogpu(); }
+void cv::gpu::CannyBuf::release() { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
@@ -106,15 +133,9 @@ void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const Gp
 
     CV_Assert((src.type() == CV_8U || src.type() == CV_8UC3) && xmap.type() == CV_32F && ymap.type() == CV_32F);
 
-    GpuMat out;
-    if (dst.data != src.data)
-        out = dst;
+    dst.create(xmap.size(), src.type());
 
-    out.create(xmap.size(), src.type());
-
-    callers[src.channels() - 1](src, xmap, ymap, out);
-
-    dst = out;
+    callers[src.channels() - 1](src, xmap, ymap, dst);
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -122,8 +143,6 @@ void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const Gp
 
 void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr, TermCriteria criteria)
 {
-    CV_Assert(TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12));
-
     if( src.empty() )
         CV_Error( CV_StsBadArg, "The input image is empty" );
 
@@ -150,8 +169,6 @@ void cv::gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,
 
 void cv::gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria)
 {
-    CV_Assert(TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12));
-
     if( src.empty() )
         CV_Error( CV_StsBadArg, "The input image is empty" );
 
@@ -182,14 +199,9 @@ namespace
     template <typename T>
     void drawColorDisp_caller(const GpuMat& src, GpuMat& dst, int ndisp, const cudaStream_t& stream)
     {
-        GpuMat out;
-        if (dst.data != src.data)
-            out = dst;
-        out.create(src.size(), CV_8UC4);
+        dst.create(src.size(), CV_8UC4);
 
-        imgproc::drawColorDisp_gpu((DevMem2D_<T>)src, out, ndisp, stream);
-
-        dst = out;
+        imgproc::drawColorDisp_gpu((DevMem2D_<T>)src, dst, ndisp, stream);
     }
 
     typedef void (*drawColorDisp_caller_t)(const GpuMat& src, GpuMat& dst, int ndisp, const cudaStream_t& stream);
@@ -270,13 +282,13 @@ void cv::gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx, doub
 
     if (src.type() == CV_8UC1)
     {
-        nppSafeCall( nppiResize_8u_C1R(src.ptr<Npp8u>(), srcsz, src.step, srcrect,
-            dst.ptr<Npp8u>(), dst.step, dstsz, fx, fy, npp_inter[interpolation]) );
+        nppSafeCall( nppiResize_8u_C1R(src.ptr<Npp8u>(), srcsz, static_cast<int>(src.step), srcrect,
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, fx, fy, npp_inter[interpolation]) );
     }
     else
     {
-        nppSafeCall( nppiResize_8u_C4R(src.ptr<Npp8u>(), srcsz, src.step, srcrect,
-            dst.ptr<Npp8u>(), dst.step, dstsz, fx, fy, npp_inter[interpolation]) );
+        nppSafeCall( nppiResize_8u_C4R(src.ptr<Npp8u>(), srcsz, static_cast<int>(src.step), srcrect,
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, fx, fy, npp_inter[interpolation]) );
     }
 
     if (stream == 0)
@@ -308,30 +320,30 @@ void cv::gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom
     case CV_8UC1:
         {
             Npp8u nVal = static_cast<Npp8u>(value[0]);
-            nppSafeCall( nppiCopyConstBorder_8u_C1R(src.ptr<Npp8u>(), src.step, srcsz,
-            dst.ptr<Npp8u>(), dst.step, dstsz, top, left, nVal) );
+            nppSafeCall( nppiCopyConstBorder_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
             break;
         }
     case CV_8UC4:
         {
             Npp8u nVal[] = {static_cast<Npp8u>(value[0]), static_cast<Npp8u>(value[1]), static_cast<Npp8u>(value[2]), static_cast<Npp8u>(value[3])};
-            nppSafeCall( nppiCopyConstBorder_8u_C4R(src.ptr<Npp8u>(), src.step, srcsz,
-                dst.ptr<Npp8u>(), dst.step, dstsz, top, left, nVal) );
+            nppSafeCall( nppiCopyConstBorder_8u_C4R(src.ptr<Npp8u>(), static_cast<int>(src.step), srcsz,
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
             break;
         }
     case CV_32SC1:
         {
             Npp32s nVal = static_cast<Npp32s>(value[0]);
-            nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), src.step, srcsz,
-                dst.ptr<Npp32s>(), dst.step, dstsz, top, left, nVal) );
+            nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
+                dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
             break;
         }
     case CV_32FC1:
         {
             Npp32f val = static_cast<Npp32f>(value[0]);
             Npp32s nVal = *(reinterpret_cast<Npp32s*>(&val));
-            nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), src.step, srcsz,
-                dst.ptr<Npp32s>(), dst.step, dstsz, top, left, nVal) );
+            nppSafeCall( nppiCopyConstBorder_32s_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), srcsz,
+                dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstsz, top, left, nVal) );
             break;
         }
     default:
@@ -392,20 +404,20 @@ namespace
         switch (src.depth())
         {
         case CV_8U:
-            nppSafeCall( npp_warp_8u[src.channels()][warpInd](src.ptr<Npp8u>(), srcsz, src.step, srcroi,
-                dst.ptr<Npp8u>(), dst.step, dstroi, coeffs, npp_inter[interpolation]) );
+            nppSafeCall( npp_warp_8u[src.channels()][warpInd](src.ptr<Npp8u>(), srcsz, static_cast<int>(src.step), srcroi,
+                dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstroi, coeffs, npp_inter[interpolation]) );
             break;
         case CV_16U:
-            nppSafeCall( npp_warp_16u[src.channels()][warpInd](src.ptr<Npp16u>(), srcsz, src.step, srcroi,
-                dst.ptr<Npp16u>(), dst.step, dstroi, coeffs, npp_inter[interpolation]) );
+            nppSafeCall( npp_warp_16u[src.channels()][warpInd](src.ptr<Npp16u>(), srcsz, static_cast<int>(src.step), srcroi,
+                dst.ptr<Npp16u>(), static_cast<int>(dst.step), dstroi, coeffs, npp_inter[interpolation]) );
             break;
         case CV_32S:
-            nppSafeCall( npp_warp_32s[src.channels()][warpInd](src.ptr<Npp32s>(), srcsz, src.step, srcroi,
-                dst.ptr<Npp32s>(), dst.step, dstroi, coeffs, npp_inter[interpolation]) );
+            nppSafeCall( npp_warp_32s[src.channels()][warpInd](src.ptr<Npp32s>(), srcsz, static_cast<int>(src.step), srcroi,
+                dst.ptr<Npp32s>(), static_cast<int>(dst.step), dstroi, coeffs, npp_inter[interpolation]) );
             break;
         case CV_32F:
-            nppSafeCall( npp_warp_32f[src.channels()][warpInd](src.ptr<Npp32f>(), srcsz, src.step, srcroi,
-                dst.ptr<Npp32f>(), dst.step, dstroi, coeffs, npp_inter[interpolation]) );
+            nppSafeCall( npp_warp_32f[src.channels()][warpInd](src.ptr<Npp32f>(), srcsz, static_cast<int>(src.step), srcroi,
+                dst.ptr<Npp32f>(), static_cast<int>(dst.step), dstroi, coeffs, npp_inter[interpolation]) );
             break;
         default:
             CV_Assert(!"Unsupported source type");
@@ -504,6 +516,79 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
     nppWarpCaller(src, dst, coeffs, dsize, flags, npp_warpPerspective_8u, npp_warpPerspective_16u, npp_warpPerspective_32s, npp_warpPerspective_32f, StreamAccessor::getStream(s));
 }
 
+//////////////////////////////////////////////////////////////////////////////
+// buildWarpPlaneMaps
+
+namespace cv { namespace gpu { namespace imgproc
+{
+    void buildWarpPlaneMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                            const float r[9], const float rinv[9], float f, float s, float dist,
+                            float half_w, float half_h, cudaStream_t stream);
+}}}
+
+void cv::gpu::buildWarpPlaneMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s,
+                                 double dist, GpuMat& map_x, GpuMat& map_y, Stream& stream)
+{
+    CV_Assert(R.size() == Size(3,3) && R.isContinuous() && R.type() == CV_32F);
+    Mat Rinv = R.inv();
+    CV_Assert(Rinv.isContinuous());
+
+    map_x.create(dst_roi.size(), CV_32F);
+    map_y.create(dst_roi.size(), CV_32F);
+    imgproc::buildWarpPlaneMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, R.ptr<float>(), Rinv.ptr<float>(),
+                                static_cast<float>(f), static_cast<float>(s), static_cast<float>(dist), 
+                                0.5f*src_size.width, 0.5f*src_size.height, StreamAccessor::getStream(stream));
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// buildWarpCylyndricalMaps
+
+namespace cv { namespace gpu { namespace imgproc
+{
+    void buildWarpCylindricalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                                  const float r[9], const float rinv[9], float f, float s,
+                                  float half_w, float half_h, cudaStream_t stream);
+}}}
+
+void cv::gpu::buildWarpCylindricalMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s,
+                                       GpuMat& map_x, GpuMat& map_y, Stream& stream)
+{
+    CV_Assert(R.size() == Size(3,3) && R.isContinuous() && R.type() == CV_32F);
+    Mat Rinv = R.inv();
+    CV_Assert(Rinv.isContinuous());
+
+    map_x.create(dst_roi.size(), CV_32F);
+    map_y.create(dst_roi.size(), CV_32F);
+    imgproc::buildWarpCylindricalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, R.ptr<float>(), Rinv.ptr<float>(),
+                                      static_cast<float>(f), static_cast<float>(s), 0.5f*src_size.width, 0.5f*src_size.height, 
+                                      StreamAccessor::getStream(stream));
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// buildWarpSphericalMaps
+
+namespace cv { namespace gpu { namespace imgproc
+{
+    void buildWarpSphericalMaps(int tl_u, int tl_v, DevMem2Df map_x, DevMem2Df map_y,
+                                const float r[9], const float rinv[9], float f, float s,
+                                float half_w, float half_h, cudaStream_t stream);
+}}}
+
+void cv::gpu::buildWarpSphericalMaps(Size src_size, Rect dst_roi, const Mat& R, double f, double s,
+                                     GpuMat& map_x, GpuMat& map_y, Stream& stream)
+{
+    CV_Assert(R.size() == Size(3,3) && R.isContinuous() && R.type() == CV_32F);
+    Mat Rinv = R.inv();
+    CV_Assert(Rinv.isContinuous());
+
+    map_x.create(dst_roi.size(), CV_32F);
+    map_y.create(dst_roi.size(), CV_32F);
+    imgproc::buildWarpSphericalMaps(dst_roi.tl().x, dst_roi.tl().y, map_x, map_y, R.ptr<float>(), Rinv.ptr<float>(),
+                                    static_cast<float>(f), static_cast<float>(s), 0.5f*src_size.width, 0.5f*src_size.height, 
+                                    StreamAccessor::getStream(stream));
+}
+
 ////////////////////////////////////////////////////////////////////////
 // rotate
 
@@ -534,13 +619,13 @@ void cv::gpu::rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, d
 
     if (src.type() == CV_8UC1)
     {
-        nppSafeCall( nppiRotate_8u_C1R(src.ptr<Npp8u>(), srcsz, src.step, srcroi,
-            dst.ptr<Npp8u>(), dst.step, dstroi, angle, xShift, yShift, npp_inter[interpolation]) );
+        nppSafeCall( nppiRotate_8u_C1R(src.ptr<Npp8u>(), srcsz, static_cast<int>(src.step), srcroi,
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstroi, angle, xShift, yShift, npp_inter[interpolation]) );
     }
     else
     {
-        nppSafeCall( nppiRotate_8u_C4R(src.ptr<Npp8u>(), srcsz, src.step, srcroi,
-            dst.ptr<Npp8u>(), dst.step, dstroi, angle, xShift, yShift, npp_inter[interpolation]) );
+        nppSafeCall( nppiRotate_8u_C4R(src.ptr<Npp8u>(), srcsz, static_cast<int>(src.step), srcroi,
+            dst.ptr<Npp8u>(), static_cast<int>(dst.step), dstroi, angle, xShift, yShift, npp_inter[interpolation]) );
     }
 
     if (stream == 0)
@@ -577,8 +662,8 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
 
     NppStStreamHandler h(stream);
 
-    nppSafeCall( nppiStIntegral_8u32u_C1R(const_cast<Ncv8u*>(src.ptr<Ncv8u>()), src.step, 
-        sum.ptr<Ncv32u>(), sum.step, roiSize, buffer.ptr<Ncv8u>(), bufSize, prop) );
+    nppSafeCall( nppiStIntegral_8u32u_C1R(const_cast<Ncv8u*>(src.ptr<Ncv8u>()), static_cast<int>(src.step), 
+        sum.ptr<Ncv32u>(), static_cast<int>(sum.step), roiSize, buffer.ptr<Ncv8u>(), bufSize, prop) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -601,8 +686,8 @@ void cv::gpu::integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum, Stream& s)
 
     NppStreamHandler h(stream);
 
-    nppSafeCall( nppiSqrIntegral_8u32s32f_C1R(const_cast<Npp8u*>(src.ptr<Npp8u>()), src.step, sum.ptr<Npp32s>(),
-        sum.step, sqsum.ptr<Npp32f>(), sqsum.step, sz, 0, 0.0f, height) );
+    nppSafeCall( nppiSqrIntegral_8u32s32f_C1R(const_cast<Npp8u*>(src.ptr<Npp8u>()), static_cast<int>(src.step), 
+        sum.ptr<Npp32s>(), static_cast<int>(sum.step), sqsum.ptr<Npp32f>(), static_cast<int>(sqsum.step), sz, 0, 0.0f, height) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -631,8 +716,8 @@ void cv::gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum, Stream& s)
     NppStStreamHandler h(stream);
 
     sqsum.create(src.rows + 1, src.cols + 1, CV_64F);
-    nppSafeCall(nppiStSqrIntegral_8u64u_C1R(const_cast<Ncv8u*>(src.ptr<Ncv8u>(0)), src.step, 
-            sqsum.ptr<Ncv64u>(0), sqsum.step, roiSize, buf.ptr<Ncv8u>(0), bufSize, prop));
+    nppSafeCall(nppiStSqrIntegral_8u64u_C1R(const_cast<Ncv8u*>(src.ptr<Ncv8u>(0)), static_cast<int>(src.step), 
+            sqsum.ptr<Ncv64u>(0), static_cast<int>(sqsum.step), roiSize, buf.ptr<Ncv8u>(0), bufSize, prop));
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -674,8 +759,8 @@ void cv::gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, cons
 
     NppStreamHandler h(stream);
 
-    nppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), src.step, sqr.ptr<Npp32f>(), sqr.step,
-                dst.ptr<Npp32f>(), dst.step, sz, nppRect) );
+    nppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step), sqr.ptr<Npp32f>(), static_cast<int>(sqr.step),
+                dst.ptr<Npp32f>(), static_cast<int>(dst.step), sz, nppRect) );
 
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -716,7 +801,7 @@ namespace
     {
         typedef typename NppHistogramEvenFuncC1<SDEPTH>::src_t src_t;
 
-        static void hist(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, cudaStream_t stream)
+        static void hist(const GpuMat& src, GpuMat& hist, GpuMat& buffer, int histSize, int lowerLevel, int upperLevel, cudaStream_t stream)
         {
             int levels = histSize + 1;
             hist.create(1, histSize, CV_32S);
@@ -725,15 +810,14 @@ namespace
             sz.width = src.cols;
             sz.height = src.rows;
 
-            GpuMat buffer;
             int buf_size;
-
             get_buf_size(sz, levels, &buf_size);
-            buffer.create(1, buf_size, CV_8U);
+
+            ensureSizeIsEnough(1, buf_size, CV_8U, buffer);
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<src_t>(), src.step, sz, hist.ptr<Npp32s>(), levels,
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), sz, hist.ptr<Npp32s>(), levels,
                 lowerLevel, upperLevel, buffer.ptr<Npp8u>()) );
 
             if (stream == 0)
@@ -745,7 +829,7 @@ namespace
     {
         typedef typename NppHistogramEvenFuncC4<SDEPTH>::src_t src_t;
 
-        static void hist(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], cudaStream_t stream)
+        static void hist(const GpuMat& src, GpuMat hist[4], GpuMat& buffer, int histSize[4], int lowerLevel[4], int upperLevel[4], cudaStream_t stream)
         {
             int levels[] = {histSize[0] + 1, histSize[1] + 1, histSize[2] + 1, histSize[3] + 1};
             hist[0].create(1, histSize[0], CV_32S);
@@ -759,15 +843,14 @@ namespace
 
             Npp32s* pHist[] = {hist[0].ptr<Npp32s>(), hist[1].ptr<Npp32s>(), hist[2].ptr<Npp32s>(), hist[3].ptr<Npp32s>()};
 
-            GpuMat buffer;
             int buf_size;
-
             get_buf_size(sz, levels, &buf_size);
-            buffer.create(1, buf_size, CV_8U);
+
+            ensureSizeIsEnough(1, buf_size, CV_8U, buffer);
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<src_t>(), src.step, sz, pHist, levels, lowerLevel, upperLevel, buffer.ptr<Npp8u>()) );
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), sz, pHist, levels, lowerLevel, upperLevel, buffer.ptr<Npp8u>()) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -818,7 +901,7 @@ namespace
         typedef typename NppHistogramRangeFuncC1<SDEPTH>::level_t level_t;
         enum {LEVEL_TYPE_CODE=NppHistogramRangeFuncC1<SDEPTH>::LEVEL_TYPE_CODE};
 
-        static void hist(const GpuMat& src, GpuMat& hist, const GpuMat& levels, cudaStream_t stream)
+        static void hist(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buffer, cudaStream_t stream)
         {
             CV_Assert(levels.type() == LEVEL_TYPE_CODE && levels.rows == 1);
 
@@ -828,15 +911,14 @@ namespace
             sz.width = src.cols;
             sz.height = src.rows;
 
-            GpuMat buffer;
             int buf_size;
-
             get_buf_size(sz, levels.cols, &buf_size);
-            buffer.create(1, buf_size, CV_8U);
+            
+            ensureSizeIsEnough(1, buf_size, CV_8U, buffer);
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<src_t>(), src.step, sz, hist.ptr<Npp32s>(), levels.ptr<level_t>(), levels.cols, buffer.ptr<Npp8u>()) );
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), sz, hist.ptr<Npp32s>(), levels.ptr<level_t>(), levels.cols, buffer.ptr<Npp8u>()) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -849,7 +931,7 @@ namespace
         typedef typename NppHistogramRangeFuncC1<SDEPTH>::level_t level_t;
         enum {LEVEL_TYPE_CODE=NppHistogramRangeFuncC1<SDEPTH>::LEVEL_TYPE_CODE};
 
-        static void hist(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], cudaStream_t stream)
+        static void hist(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buffer, cudaStream_t stream)
         {
             CV_Assert(levels[0].type() == LEVEL_TYPE_CODE && levels[0].rows == 1);
             CV_Assert(levels[1].type() == LEVEL_TYPE_CODE && levels[1].rows == 1);
@@ -869,15 +951,14 @@ namespace
             sz.width = src.cols;
             sz.height = src.rows;
 
-            GpuMat buffer;
             int buf_size;
-
             get_buf_size(sz, nLevels, &buf_size);
-            buffer.create(1, buf_size, CV_8U);
+
+            ensureSizeIsEnough(1, buf_size, CV_8U, buffer);
 
             NppStreamHandler h(stream);
 
-            nppSafeCall( func(src.ptr<src_t>(), src.step, sz, pHist, pLevels, nLevels, buffer.ptr<Npp8u>()) );
+            nppSafeCall( func(src.ptr<src_t>(), static_cast<int>(src.step), sz, pHist, pLevels, nLevels, buffer.ptr<Npp8u>()) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -893,10 +974,16 @@ void cv::gpu::evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperL
 }
 
 void cv::gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel, Stream& stream)
+{
+    GpuMat buf;
+    histEven(src, hist, buf, histSize, lowerLevel, upperLevel, stream);
+}
+
+void cv::gpu::histEven(const GpuMat& src, GpuMat& hist, GpuMat& buf, int histSize, int lowerLevel, int upperLevel, Stream& stream)
 {
     CV_Assert(src.type() == CV_8UC1 || src.type() == CV_16UC1 || src.type() == CV_16SC1 );
 
-    typedef void (*hist_t)(const GpuMat& src, GpuMat& hist, int levels, int lowerLevel, int upperLevel, cudaStream_t stream);
+    typedef void (*hist_t)(const GpuMat& src, GpuMat& hist, GpuMat& buf, int levels, int lowerLevel, int upperLevel, cudaStream_t stream);
     static const hist_t hist_callers[] =
     {
         NppHistogramEvenC1<CV_8U , nppiHistogramEven_8u_C1R , nppiHistogramEvenGetBufferSize_8u_C1R >::hist,
@@ -905,14 +992,20 @@ void cv::gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerL
         NppHistogramEvenC1<CV_16S, nppiHistogramEven_16s_C1R, nppiHistogramEvenGetBufferSize_16s_C1R>::hist
     };
 
-    hist_callers[src.depth()](src, hist, histSize, lowerLevel, upperLevel, StreamAccessor::getStream(stream));
+    hist_callers[src.depth()](src, hist, buf, histSize, lowerLevel, upperLevel, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream)
+{
+    GpuMat buf;
+    histEven(src, hist, buf, histSize, lowerLevel, upperLevel, stream);
+}
+
+void cv::gpu::histEven(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int histSize[4], int lowerLevel[4], int upperLevel[4], Stream& stream)
 {
     CV_Assert(src.type() == CV_8UC4 || src.type() == CV_16UC4 || src.type() == CV_16SC4 );
 
-    typedef void (*hist_t)(const GpuMat& src, GpuMat hist[4], int levels[4], int lowerLevel[4], int upperLevel[4], cudaStream_t stream);
+    typedef void (*hist_t)(const GpuMat& src, GpuMat hist[4], GpuMat& buf, int levels[4], int lowerLevel[4], int upperLevel[4], cudaStream_t stream);
     static const hist_t hist_callers[] =
     {
         NppHistogramEvenC4<CV_8U , nppiHistogramEven_8u_C4R , nppiHistogramEvenGetBufferSize_8u_C4R >::hist,
@@ -921,14 +1014,21 @@ void cv::gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int l
         NppHistogramEvenC4<CV_16S, nppiHistogramEven_16s_C4R, nppiHistogramEvenGetBufferSize_16s_C4R>::hist
     };
 
-    hist_callers[src.depth()](src, hist, histSize, lowerLevel, upperLevel, StreamAccessor::getStream(stream));
+    hist_callers[src.depth()](src, hist, buf, histSize, lowerLevel, upperLevel, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, Stream& stream)
+{
+    GpuMat buf;
+    histRange(src, hist, levels, buf, stream);
+}
+
+
+void cv::gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, Stream& stream)
 {
     CV_Assert(src.type() == CV_8UC1 || src.type() == CV_16UC1 || src.type() == CV_16SC1 || src.type() == CV_32FC1);
 
-    typedef void (*hist_t)(const GpuMat& src, GpuMat& hist, const GpuMat& levels, cudaStream_t stream);
+    typedef void (*hist_t)(const GpuMat& src, GpuMat& hist, const GpuMat& levels, GpuMat& buf, cudaStream_t stream);
     static const hist_t hist_callers[] =
     {
         NppHistogramRangeC1<CV_8U , nppiHistogramRange_8u_C1R , nppiHistogramRangeGetBufferSize_8u_C1R >::hist,
@@ -939,14 +1039,20 @@ void cv::gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels, S
         NppHistogramRangeC1<CV_32F, nppiHistogramRange_32f_C1R, nppiHistogramRangeGetBufferSize_32f_C1R>::hist
     };
 
-    hist_callers[src.depth()](src, hist, levels, StreamAccessor::getStream(stream));
+    hist_callers[src.depth()](src, hist, levels, buf, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], Stream& stream)
+{
+    GpuMat buf;
+    histRange(src, hist, levels, buf, stream);
+}
+
+void cv::gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, Stream& stream)
 {
     CV_Assert(src.type() == CV_8UC4 || src.type() == CV_16UC4 || src.type() == CV_16SC4 || src.type() == CV_32FC4);
 
-    typedef void (*hist_t)(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], cudaStream_t stream);
+    typedef void (*hist_t)(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4], GpuMat& buf, cudaStream_t stream);
     static const hist_t hist_callers[] =
     {
         NppHistogramRangeC4<CV_8U , nppiHistogramRange_8u_C4R , nppiHistogramRangeGetBufferSize_8u_C4R >::hist,
@@ -957,7 +1063,85 @@ void cv::gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4
         NppHistogramRangeC4<CV_32F, nppiHistogramRange_32f_C4R, nppiHistogramRangeGetBufferSize_32f_C4R>::hist
     };
 
-    hist_callers[src.depth()](src, hist, levels, StreamAccessor::getStream(stream));
+    hist_callers[src.depth()](src, hist, levels, buf, StreamAccessor::getStream(stream));
+}
+
+namespace cv { namespace gpu { namespace histograms
+{
+    void histogram256_gpu(DevMem2D src, int* hist, unsigned int* buf, cudaStream_t stream);
+
+    const int PARTIAL_HISTOGRAM256_COUNT = 240;
+    const int HISTOGRAM256_BIN_COUNT     = 256;
+}}}
+
+void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, Stream& stream)
+{
+    GpuMat buf;
+    calcHist(src, hist, buf, stream);
+}
+
+void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream)
+{
+    using namespace cv::gpu::histograms;
+
+    CV_Assert(src.type() == CV_8UC1);
+
+    hist.create(1, 256, CV_32SC1);
+
+    ensureSizeIsEnough(1, PARTIAL_HISTOGRAM256_COUNT * HISTOGRAM256_BIN_COUNT, CV_32SC1, buf);
+
+    histogram256_gpu(src, hist.ptr<int>(), buf.ptr<unsigned int>(), StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+    GpuMat hist;
+    GpuMat buf;
+    equalizeHist(src, dst, hist, buf, stream);
+}
+
+void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream)
+{
+    GpuMat buf;
+    equalizeHist(src, dst, hist, buf, stream);
+}
+
+namespace cv { namespace gpu { namespace histograms
+{
+    void equalizeHist_gpu(DevMem2D src, DevMem2D dst, const int* lut, cudaStream_t stream);
+}}}
+
+void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& s)
+{
+    using namespace cv::gpu::histograms;
+
+    CV_Assert(src.type() == CV_8UC1);
+
+    dst.create(src.size(), src.type());
+
+    int intBufSize;
+    nppSafeCall( nppsIntegralGetBufferSize_32s(256, &intBufSize) );
+
+    int bufSize = static_cast<int>(std::max(256 * 240 * sizeof(int), intBufSize + 256 * sizeof(int)));
+
+    ensureSizeIsEnough(1, bufSize, CV_8UC1, buf);
+
+    GpuMat histBuf(1, 256 * 240, CV_32SC1, buf.ptr());
+    GpuMat intBuf(1, intBufSize, CV_8UC1, buf.ptr());
+    GpuMat lut(1, 256, CV_32S, buf.ptr() + intBufSize);
+
+    calcHist(src, hist, histBuf, s);
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    NppStreamHandler h(stream);
+
+    nppSafeCall( nppsIntegral_32s(hist.ptr<Npp32s>(), lut.ptr<Npp32s>(), 256, intBuf.ptr<Npp8u>()) );
+    
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+    equalizeHist_gpu(src, dst, lut.ptr<int>(), stream);
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -983,7 +1167,6 @@ namespace
             scale *= 255.;
         scale = 1./scale;
 
-        GpuMat tmp_buf(src.size(), CV_32F);
         Dx.create(src.size(), CV_32F);
         Dy.create(src.size(), CV_32F);
 
@@ -1041,6 +1224,12 @@ bool cv::gpu::tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType)
 }
 
 void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType)
+{
+    GpuMat Dx, Dy;
+    cornerHarris(src, dst, Dx, Dy, blockSize, ksize, k, borderType);
+}
+
+void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, double k, int borderType)
 {
     CV_Assert(borderType == cv::BORDER_REFLECT101 ||
               borderType == cv::BORDER_REPLICATE);
@@ -1048,13 +1237,18 @@ void cv::gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ks
     int gpuBorderType;
     CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
 
-    GpuMat Dx, Dy;
     extractCovData(src, Dx, Dy, blockSize, ksize, borderType);
     dst.create(src.size(), CV_32F);
     imgproc::cornerHarris_caller(blockSize, (float)k, Dx, Dy, dst, gpuBorderType);
 }
 
 void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType)
+{  
+    GpuMat Dx, Dy;
+    cornerMinEigenVal(src, dst, Dx, Dy, blockSize, ksize, borderType);
+}
+
+void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, GpuMat& Dx, GpuMat& Dy, int blockSize, int ksize, int borderType)
 {  
     CV_Assert(borderType == cv::BORDER_REFLECT101 ||
               borderType == cv::BORDER_REPLICATE);
@@ -1062,7 +1256,6 @@ void cv::gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, i
     int gpuBorderType;
     CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
 
-    GpuMat Dx, Dy;
     extractCovData(src, Dx, Dy, blockSize, ksize, borderType);    
     dst.create(src.size(), CV_32F);
     imgproc::cornerMinEigenVal_caller(blockSize, Dx, Dy, dst, gpuBorderType);
@@ -1333,34 +1526,283 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
     cufftSafeCall(cufftDestroy(planC2R));
 }
 
+
 ////////////////////////////////////////////////////////////////////
 // downsample
 
 namespace cv { namespace gpu { namespace imgproc
 {
-    template <typename T>
-    void downsampleCaller(const PtrStep_<T> src, int rows, int cols, int k, PtrStep_<T> dst);
+    template <typename T, int cn>
+    void downsampleCaller(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
 }}}
 
-void cv::gpu::downsample(const GpuMat& src, GpuMat& dst, int k)
+
+void cv::gpu::downsample(const GpuMat& src, GpuMat& dst, Stream& stream)
 {
-    CV_Assert(src.channels() == 1);    
+    CV_Assert(src.depth() < CV_64F && src.channels() <= 4);
 
-    dst.create((src.rows + k - 1) / k, (src.cols + k - 1) / k, src.type());
+    typedef void (*Caller)(const DevMem2D, DevMem2D, cudaStream_t stream);
+    static const Caller callers[6][4] =
+        {{imgproc::downsampleCaller<uchar,1>, imgproc::downsampleCaller<uchar,2>,
+          imgproc::downsampleCaller<uchar,3>, imgproc::downsampleCaller<uchar,4>},
+         {0,0,0,0}, {0,0,0,0},
+         {imgproc::downsampleCaller<short,1>, imgproc::downsampleCaller<short,2>,
+          imgproc::downsampleCaller<short,3>, imgproc::downsampleCaller<short,4>},
+         {0,0,0,0},
+         {imgproc::downsampleCaller<float,1>, imgproc::downsampleCaller<float,2>,
+          imgproc::downsampleCaller<float,3>, imgproc::downsampleCaller<float,4>}};
 
-    switch (src.depth())
+    Caller caller = callers[src.depth()][src.channels()-1];
+    if (!caller)
+        CV_Error(CV_StsUnsupportedFormat, "bad number of channels");
+
+    dst.create((src.rows + 1) / 2, (src.cols + 1) / 2, src.type());
+    caller(src, dst.reshape(1), StreamAccessor::getStream(stream));
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// upsample
+
+namespace cv { namespace gpu { namespace imgproc
+{
+    template <typename T, int cn>
+    void upsampleCaller(const DevMem2D src, DevMem2D dst, cudaStream_t stream);
+}}}
+
+
+void cv::gpu::upsample(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+    CV_Assert(src.depth() < CV_64F && src.channels() <= 4);
+
+    typedef void (*Caller)(const DevMem2D, DevMem2D, cudaStream_t stream);
+    static const Caller callers[6][5] =
+        {{imgproc::upsampleCaller<uchar,1>, imgproc::upsampleCaller<uchar,2>,
+          imgproc::upsampleCaller<uchar,3>, imgproc::upsampleCaller<uchar,4>},
+         {0,0,0,0}, {0,0,0,0},
+         {imgproc::upsampleCaller<short,1>, imgproc::upsampleCaller<short,2>,
+          imgproc::upsampleCaller<short,3>, imgproc::upsampleCaller<short,4>},
+         {0,0,0,0},
+         {imgproc::upsampleCaller<float,1>, imgproc::upsampleCaller<float,2>,
+          imgproc::upsampleCaller<float,3>, imgproc::upsampleCaller<float,4>}};
+
+    Caller caller = callers[src.depth()][src.channels()-1];
+    if (!caller)
+        CV_Error(CV_StsUnsupportedFormat, "bad number of channels");
+
+    dst.create(src.rows*2, src.cols*2, src.type());
+    caller(src, dst.reshape(1), StreamAccessor::getStream(stream));
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// pyrDown
+
+void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+    PyrDownBuf buf;
+    pyrDown(src, dst, buf, stream);
+}
+
+cv::Mat cv::gpu::PyrDownBuf::ker;
+
+void cv::gpu::PyrDownBuf::create(Size image_size, int image_type_)
+{
+    if (ker.empty() || image_type_ != image_type)
+        ker = getGaussianKernel(5, 0, std::max(CV_32F, CV_MAT_DEPTH(image_type_)));
+
+    ensureSizeIsEnough(image_size.height, image_size.width, image_type_, buf);
+
+    if (filter.empty() || image_type_ != image_type)
     {
-    case CV_8U:
-        imgproc::downsampleCaller<uchar>(src, dst.rows, dst.cols, k, dst);
-        break;
-    case CV_32F:
-        imgproc::downsampleCaller<float>(src, dst.rows, dst.cols, k, dst);
-        break;
-    default:
-        CV_Error(CV_StsUnsupportedFormat, "bad image depth in downsample function");
+        image_type = image_type_;
+        filter = createSeparableLinearFilter_GPU(image_type, image_type, ker, ker);
     }
 }
 
+void cv::gpu::pyrDown(const GpuMat& src, GpuMat& dst, PyrDownBuf& buf, Stream& stream)
+{
+    buf.create(src.size(), src.type());
+    buf.filter->apply(src, buf.buf, Rect(0, 0, src.cols, src.rows), stream);
+    downsample(buf.buf, dst, stream);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// pyrUp
+
+void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+    PyrUpBuf buf;
+    pyrUp(src, dst, buf, stream);
+}
+
+cv::Mat cv::gpu::PyrUpBuf::ker;
+
+void cv::gpu::PyrUpBuf::create(Size image_size, int image_type_)
+{
+    if (ker.empty() || image_type_ != image_type)
+        ker = getGaussianKernel(5, 0, std::max(CV_32F, CV_MAT_DEPTH(image_type_))) * 2;
+
+    ensureSizeIsEnough(image_size.height * 2, image_size.width * 2, image_type_, buf);
+
+    if (filter.empty() || image_type_ != image_type)
+    {
+        image_type = image_type_;
+        filter = createSeparableLinearFilter_GPU(image_type, image_type, ker, ker);
+    }
+}
+
+void cv::gpu::pyrUp(const GpuMat& src, GpuMat& dst, PyrUpBuf& buf, Stream& stream)
+{
+    buf.create(src.size(), src.type());
+    upsample(src, buf.buf, stream);
+    buf.filter->apply(buf.buf, dst, Rect(0, 0, buf.buf.cols, buf.buf.rows), stream);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Canny
+
+cv::gpu::CannyBuf::CannyBuf(const GpuMat& dx_, const GpuMat& dy_) : dx(dx_), dy(dy_)
+{
+    CV_Assert(dx_.type() == CV_32SC1 && dy_.type() == CV_32SC1 && dx_.size() == dy_.size());
+
+    create(dx_.size(), -1);
+}
+
+void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size)
+{
+    ensureSizeIsEnough(image_size, CV_32SC1, dx);
+    ensureSizeIsEnough(image_size, CV_32SC1, dy);
+
+    if (apperture_size == 3)
+    {
+        ensureSizeIsEnough(image_size, CV_32SC1, dx_buf);
+        ensureSizeIsEnough(image_size, CV_32SC1, dy_buf);
+    }
+    else if(apperture_size > 0)
+    {
+        if (!filterDX)
+            filterDX = createDerivFilter_GPU(CV_8UC1, CV_32S, 1, 0, apperture_size, BORDER_REPLICATE);
+        if (!filterDY)
+            filterDY = createDerivFilter_GPU(CV_8UC1, CV_32S, 0, 1, apperture_size, BORDER_REPLICATE);
+    }
+
+    ensureSizeIsEnough(image_size.height + 2, image_size.width + 2, CV_32FC1, edgeBuf);
+
+    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf1);
+    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf2);
+}
+
+void cv::gpu::CannyBuf::release()
+{
+    dx.release();
+    dy.release();
+    dx_buf.release();
+    dy_buf.release();
+    edgeBuf.release();
+    trackBuf1.release();
+    trackBuf2.release();
+}
+
+namespace cv { namespace gpu { namespace canny
+{    
+    void calcSobelRowPass_gpu(PtrStep src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols);
+
+    void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
+    void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
+
+    void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh);
+    
+    void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols);
+
+    void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols);
+
+    void getEdges_gpu(PtrStepi map, PtrStep dst, int rows, int cols);
+}}}
+
+namespace
+{
+    void CannyCaller(CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh)
+    {
+        using namespace cv::gpu::canny;
+
+        calcMap_gpu(buf.dx, buf.dy, buf.edgeBuf, buf.edgeBuf, dst.rows, dst.cols, low_thresh, high_thresh);
+        
+        edgesHysteresisLocal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), dst.rows, dst.cols);
+        
+        edgesHysteresisGlobal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), buf.trackBuf2.ptr<ushort2>(), dst.rows, dst.cols);
+        
+        getEdges_gpu(buf.edgeBuf, dst, dst.rows, dst.cols);
+    }
+}
+
+void cv::gpu::Canny(const GpuMat& src, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient)
+{
+    CannyBuf buf(src.size(), apperture_size);
+    Canny(src, buf, dst, low_thresh, high_thresh, apperture_size, L2gradient);
+}
+
+void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient)
+{
+    using namespace cv::gpu::canny;
+
+    CV_Assert(src.type() == CV_8UC1);
+
+    if( low_thresh > high_thresh )
+        std::swap( low_thresh, high_thresh);
+
+    dst.create(src.size(), CV_8U);
+    dst.setTo(Scalar::all(0));
+    
+    buf.create(src.size(), apperture_size);
+    buf.edgeBuf.setTo(Scalar::all(0));
+
+    if (apperture_size == 3)
+    {
+        calcSobelRowPass_gpu(src, buf.dx_buf, buf.dy_buf, src.rows, src.cols);
+
+        calcMagnitude_gpu(buf.dx_buf, buf.dy_buf, buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+    }
+    else
+    {
+        buf.filterDX->apply(src, buf.dx, Rect(0, 0, src.cols, src.rows));
+        buf.filterDY->apply(src, buf.dy, Rect(0, 0, src.cols, src.rows));
+
+        calcMagnitude_gpu(buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+    }
+
+    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+}
+
+void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient)
+{
+    CannyBuf buf(dx, dy);
+    Canny(dx, dy, buf, dst, low_thresh, high_thresh, L2gradient);
+}
+
+void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient)
+{
+    using namespace cv::gpu::canny;
+
+    CV_Assert(dx.type() == CV_32SC1 && dy.type() == CV_32SC1 && dx.size() == dy.size());
+
+    if( low_thresh > high_thresh )
+        std::swap( low_thresh, high_thresh);
+
+    dst.create(dx.size(), CV_8U);
+    dst.setTo(Scalar::all(0));
+    
+    buf.dx = dx; buf.dy = dy;
+    buf.create(dx.size(), -1);
+    buf.edgeBuf.setTo(Scalar::all(0));
+
+    calcMagnitude_gpu(dx, dy, buf.edgeBuf, dx.rows, dx.cols, L2gradient);
+
+    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+}
+
 #endif /* !defined (HAVE_CUDA) */
 
 
diff --git a/modules/gpu/src/initialization.cpp b/modules/gpu/src/initialization.cpp
index 2b7ceea90a..b13c173a36 100644
--- a/modules/gpu/src/initialization.cpp
+++ b/modules/gpu/src/initialization.cpp
@@ -177,8 +177,16 @@ void cv::gpu::DeviceInfo::queryMemory(size_t&, size_t&) const { throw_nogpu(); }
 int cv::gpu::getCudaEnabledDeviceCount()
 {
     int count;
-    cudaSafeCall( cudaGetDeviceCount( &count ) );
-    return count;
+    cudaError_t error = cudaGetDeviceCount( &count );
+
+    if (error == cudaErrorInsufficientDriver)
+        return -1;
+
+    if (error == cudaErrorNoDevice)
+        return 0;
+
+    cudaSafeCall(error);
+    return count;  
 }
 
 
@@ -190,17 +198,9 @@ void cv::gpu::setDevice(int device)
 
 int cv::gpu::getDevice()
 {
-    int count;
-    cudaError_t error = cudaGetDeviceCount( &count );
-
-    if (error == cudaErrorInsufficientDriver)
-        return -1;
-
-    if (error == cudaErrorNoDevice)
-        return 0;
-
-    cudaSafeCall(error);
-    return count;
+    int device;    
+    cudaSafeCall( cudaGetDevice( &device ) );
+    return device;
 }
 
 
diff --git a/modules/gpu/src/matrix_operations.cpp b/modules/gpu/src/matrix_operations.cpp
index 3d802807df..874e6e506d 100644
--- a/modules/gpu/src/matrix_operations.cpp
+++ b/modules/gpu/src/matrix_operations.cpp
@@ -45,564 +45,27 @@
 using namespace cv;
 using namespace cv::gpu;
 
-////////////////////////////////////////////////////////////////////////
-//////////////////////////////// GpuMat ////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-
-
 #if !defined (HAVE_CUDA)
 
-namespace cv
-{
-    namespace gpu
-    {
-        void GpuMat::upload(const Mat& /*m*/) { throw_nogpu(); }
-        void GpuMat::download(cv::Mat& /*m*/) const { throw_nogpu(); }
-        void GpuMat::copyTo( GpuMat& /*m*/ ) const { throw_nogpu(); }
-        void GpuMat::copyTo( GpuMat& /*m*/, const GpuMat&/* mask */) const { throw_nogpu(); }
-        void GpuMat::convertTo( GpuMat& /*m*/, int /*rtype*/, double /*alpha*/, double /*beta*/ ) const { throw_nogpu(); }
-        GpuMat& GpuMat::operator = (const Scalar& /*s*/) { throw_nogpu(); return *this; }
-        GpuMat& GpuMat::setTo(const Scalar& /*s*/, const GpuMat& /*mask*/) { throw_nogpu(); return *this; }
-        GpuMat GpuMat::reshape(int /*new_cn*/, int /*new_rows*/) const { throw_nogpu(); return GpuMat(); }
-        void GpuMat::create(int /*_rows*/, int /*_cols*/, int /*_type*/) { throw_nogpu(); }
-        void GpuMat::release() {}
-
-        void createContinuous(int /*rows*/, int /*cols*/, int /*type*/, GpuMat& /*m*/) { throw_nogpu(); }
-
-        void CudaMem::create(int /*_rows*/, int /*_cols*/, int /*_type*/, int /*type_alloc*/) { throw_nogpu(); }
-        bool CudaMem::canMapHostMemory() { throw_nogpu(); return false; }
-        void CudaMem::release() { throw_nogpu(); }
-        GpuMat CudaMem::createGpuMatHeader () const { throw_nogpu(); return GpuMat(); }
-    }
-
-}
+void cv::gpu::registerPageLocked(Mat&) { throw_nogpu(); }
+void cv::gpu::unregisterPageLocked(Mat&) { throw_nogpu(); }
+void cv::gpu::CudaMem::create(int /*_rows*/, int /*_cols*/, int /*_type*/, int /*type_alloc*/) { throw_nogpu(); }
+bool cv::gpu::CudaMem::canMapHostMemory() { throw_nogpu(); return false; }
+void cv::gpu::CudaMem::release() { throw_nogpu(); }
+GpuMat cv::gpu::CudaMem::createGpuMatHeader () const { throw_nogpu(); return GpuMat(); }
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv
+void registerPageLocked(Mat& m)
 {
-    namespace gpu
-    {
-        namespace matrix_operations
-        {
-            void copy_to_with_mask(const DevMem2D& src, DevMem2D dst, int depth, const DevMem2D& mask, int channels, const cudaStream_t & stream = 0);
-
-            template <typename T>
-            void set_to_gpu(const DevMem2D& mat, const T* scalar, int channels, cudaStream_t stream);
-            template <typename T>
-            void set_to_gpu(const DevMem2D& mat, const T* scalar, const DevMem2D& mask, int channels, cudaStream_t stream);
-
-            void convert_gpu(const DevMem2D& src, int sdepth, const DevMem2D& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
-        }
-    }
+    cudaSafeCall( cudaHostRegister(m.ptr(), m.step * m.rows, cudaHostRegisterPortable) );
 }
 
-void cv::gpu::GpuMat::upload(const Mat& m)
+void unregisterPageLocked(Mat& m)
 {
-    CV_DbgAssert(!m.empty());
-    create(m.size(), m.type());
-    cudaSafeCall( cudaMemcpy2D(data, step, m.data, m.step, cols * elemSize(), rows, cudaMemcpyHostToDevice) );
+    cudaSafeCall( cudaHostUnregister(m.ptr()) );
 }
 
-void cv::gpu::GpuMat::upload(const CudaMem& m, Stream& stream)
-{
-    CV_DbgAssert(!m.empty());
-    stream.enqueueUpload(m, *this);
-}
-
-void cv::gpu::GpuMat::download(cv::Mat& m) const
-{
-    CV_DbgAssert(!this->empty());
-    m.create(size(), type());
-    cudaSafeCall( cudaMemcpy2D(m.data, m.step, data, step, cols * elemSize(), rows, cudaMemcpyDeviceToHost) );
-}
-
-void cv::gpu::GpuMat::download(CudaMem& m, Stream& stream) const
-{
-    CV_DbgAssert(!m.empty());
-    stream.enqueueDownload(*this, m);
-}
-
-void cv::gpu::GpuMat::copyTo( GpuMat& m ) const
-{
-    CV_DbgAssert(!this->empty());
-    m.create(size(), type());
-    cudaSafeCall( cudaMemcpy2D(m.data, m.step, data, step, cols * elemSize(), rows, cudaMemcpyDeviceToDevice) );
-    cudaSafeCall( cudaDeviceSynchronize() );
-}
-
-void cv::gpu::GpuMat::copyTo( GpuMat& mat, const GpuMat& mask ) const
-{
-    if (mask.empty())
-    {
-        copyTo(mat);
-    }
-    else
-    {
-        mat.create(size(), type());
-        cv::gpu::matrix_operations::copy_to_with_mask(*this, mat, depth(), mask, channels());
-    }
-}
-
-namespace
-{
-    template<int n> struct NPPTypeTraits;
-    template<> struct NPPTypeTraits<CV_8U>  { typedef Npp8u npp_type; };
-    template<> struct NPPTypeTraits<CV_16U> { typedef Npp16u npp_type; };
-    template<> struct NPPTypeTraits<CV_16S> { typedef Npp16s npp_type; };
-    template<> struct NPPTypeTraits<CV_32S> { typedef Npp32s npp_type; };
-    template<> struct NPPTypeTraits<CV_32F> { typedef Npp32f npp_type; };
-
-    template<int SDEPTH, int DDEPTH> struct NppConvertFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        typedef NppStatus (*func_ptr)(const src_t* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI);
-    };
-    template<int DDEPTH> struct NppConvertFunc<CV_32F, DDEPTH>
-    {
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        typedef NppStatus (*func_ptr)(const Npp32f* pSrc, int nSrcStep, dst_t* pDst, int nDstStep, NppiSize oSizeROI, NppRoundMode eRoundMode);
-    };
-
-    template<int SDEPTH, int DDEPTH, typename NppConvertFunc<SDEPTH, DDEPTH>::func_ptr func> struct NppCvt
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        static void cvt(const GpuMat& src, GpuMat& dst)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            nppSafeCall( func(src.ptr<src_t>(), src.step, dst.ptr<dst_t>(), dst.step, sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int DDEPTH, typename NppConvertFunc<CV_32F, DDEPTH>::func_ptr func> struct NppCvt<CV_32F, DDEPTH, func>
-    {
-        typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
-
-        static void cvt(const GpuMat& src, GpuMat& dst)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            nppSafeCall( func(src.ptr<Npp32f>(), src.step, dst.ptr<dst_t>(), dst.step, sz, NPP_RND_NEAR) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    void convertToKernelCaller(const GpuMat& src, GpuMat& dst)
-    {
-        matrix_operations::convert_gpu(src.reshape(1), src.depth(), dst.reshape(1), dst.depth(), 1.0, 0.0);
-    }
-}
-
-void cv::gpu::GpuMat::convertTo( GpuMat& dst, int rtype, double alpha, double beta ) const
-{
-    CV_Assert((depth() != CV_64F && CV_MAT_DEPTH(rtype) != CV_64F) || 
-        (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE)));
-
-    bool noScale = fabs(alpha-1) < std::numeric_limits<double>::epsilon() && fabs(beta) < std::numeric_limits<double>::epsilon();
-
-    if( rtype < 0 )
-        rtype = type();
-    else
-        rtype = CV_MAKETYPE(CV_MAT_DEPTH(rtype), channels());
-
-    int scn = channels();
-    int sdepth = depth(), ddepth = CV_MAT_DEPTH(rtype);
-    if( sdepth == ddepth && noScale )
-    {
-        copyTo(dst);
-        return;
-    }
-
-    GpuMat temp;
-    const GpuMat* psrc = this;
-    if( sdepth != ddepth && psrc == &dst )
-        psrc = &(temp = *this);
-
-    dst.create( size(), rtype );
-
-    if (!noScale)
-        matrix_operations::convert_gpu(psrc->reshape(1), sdepth, dst.reshape(1), ddepth, alpha, beta);
-    else
-    {
-        typedef void (*convert_caller_t)(const GpuMat& src, GpuMat& dst);
-        static const convert_caller_t convert_callers[8][8][4] =
-        {
-            {
-                {0,0,0,0},
-                {convertToKernelCaller, convertToKernelCaller, convertToKernelCaller, convertToKernelCaller},
-                {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::cvt},
-                {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::cvt},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::cvt},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::cvt},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {NppCvt<CV_32F, CV_8U, nppiConvert_32f8u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::cvt,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0}
-            },
-            {
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {convertToKernelCaller,convertToKernelCaller,convertToKernelCaller,convertToKernelCaller},
-                {0,0,0,0},
-                {0,0,0,0}
-            },
-            {
-                {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}
-            }
-        };
-
-        convert_callers[sdepth][ddepth][scn-1](*psrc, dst);
-    }
-}
-
-GpuMat& GpuMat::operator = (const Scalar& s)
-{
-    setTo(s);
-    return *this;
-}
-
-namespace
-{
-    template<int SDEPTH, int SCN> struct NppSetFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
-    };
-    template<int SDEPTH> struct NppSetFunc<SDEPTH, 1>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI);
-    };
-
-    template<int SDEPTH, int SCN, typename NppSetFunc<SDEPTH, SCN>::func_ptr func> struct NppSet
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            Scalar_<src_t> nppS = s;
-            nppSafeCall( func(nppS.val, src.ptr<src_t>(), src.step, sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int SDEPTH, typename NppSetFunc<SDEPTH, 1>::func_ptr func> struct NppSet<SDEPTH, 1, func>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            Scalar_<src_t> nppS = s;
-            nppSafeCall( func(nppS[0], src.ptr<src_t>(), src.step, sz) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    template <typename T>
-    void kernelSet(GpuMat& src, const Scalar& s)
-    {
-        Scalar_<T> sf = s;
-        matrix_operations::set_to_gpu(src, sf.val, src.channels(), 0);
-    }
-
-    template<int SDEPTH, int SCN> struct NppSetMaskFunc
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(const src_t values[], src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
-    };
-    template<int SDEPTH> struct NppSetMaskFunc<SDEPTH, 1>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        typedef NppStatus (*func_ptr)(src_t val, src_t* pSrc, int nSrcStep, NppiSize oSizeROI, const Npp8u* pMask, int nMaskStep);
-    };
-
-    template<int SDEPTH, int SCN, typename NppSetMaskFunc<SDEPTH, SCN>::func_ptr func> struct NppSetMask
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            Scalar_<src_t> nppS = s;
-            nppSafeCall( func(nppS.val, src.ptr<src_t>(), src.step, sz, mask.ptr<Npp8u>(), mask.step) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template<int SDEPTH, typename NppSetMaskFunc<SDEPTH, 1>::func_ptr func> struct NppSetMask<SDEPTH, 1, func>
-    {
-        typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
-
-        static void set(GpuMat& src, const Scalar& s, const GpuMat& mask)
-        {
-            NppiSize sz;
-            sz.width = src.cols;
-            sz.height = src.rows;
-            Scalar_<src_t> nppS = s;
-            nppSafeCall( func(nppS[0], src.ptr<src_t>(), src.step, sz, mask.ptr<Npp8u>(), mask.step) );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    template <typename T>
-    void kernelSetMask(GpuMat& src, const Scalar& s, const GpuMat& mask)
-    {
-        Scalar_<T> sf = s;
-        matrix_operations::set_to_gpu(src, sf.val, mask, src.channels(), 0);
-    }
-}
-
-GpuMat& GpuMat::setTo(const Scalar& s, const GpuMat& mask)
-{
-    CV_Assert(mask.type() == CV_8UC1);
-
-    CV_Assert((depth() != CV_64F) || 
-        (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE)));
-
-    CV_DbgAssert(!this->empty());
-
-    NppiSize sz;
-    sz.width  = cols;
-    sz.height = rows;
-
-    if (mask.empty())
-    {
-        if (s[0] == 0.0 && s[1] == 0.0 && s[2] == 0.0 && s[3] == 0.0)
-        {
-            cudaSafeCall( cudaMemset2D(data, step, 0, cols * elemSize(), rows) );
-            return *this;
-        }
-        if (depth() == CV_8U)
-        {
-            int cn = channels();
-
-            if (cn == 1 || (cn == 2 && s[0] == s[1]) || (cn == 3 && s[0] == s[1] && s[0] == s[2]) || (cn == 4 && s[0] == s[1] && s[0] == s[2] && s[0] == s[3]))
-            {
-                int val = saturate_cast<uchar>(s[0]);
-                cudaSafeCall( cudaMemset2D(data, step, val, cols * elemSize(), rows) );
-                return *this;
-            }
-        }
-        typedef void (*set_caller_t)(GpuMat& src, const Scalar& s);
-        static const set_caller_t set_callers[8][4] =
-        {
-            {NppSet<CV_8U, 1, nppiSet_8u_C1R>::set,kernelSet<uchar>,kernelSet<uchar>,NppSet<CV_8U, 4, nppiSet_8u_C4R>::set},
-            {kernelSet<schar>,kernelSet<schar>,kernelSet<schar>,kernelSet<schar>},
-            {NppSet<CV_16U, 1, nppiSet_16u_C1R>::set,NppSet<CV_16U, 2, nppiSet_16u_C2R>::set,kernelSet<ushort>,NppSet<CV_16U, 4, nppiSet_16u_C4R>::set},
-            {NppSet<CV_16S, 1, nppiSet_16s_C1R>::set,NppSet<CV_16S, 2, nppiSet_16s_C2R>::set,kernelSet<short>,NppSet<CV_16S, 4, nppiSet_16s_C4R>::set},
-            {NppSet<CV_32S, 1, nppiSet_32s_C1R>::set,kernelSet<int>,kernelSet<int>,NppSet<CV_32S, 4, nppiSet_32s_C4R>::set},
-            {NppSet<CV_32F, 1, nppiSet_32f_C1R>::set,kernelSet<float>,kernelSet<float>,NppSet<CV_32F, 4, nppiSet_32f_C4R>::set},
-            {kernelSet<double>,kernelSet<double>,kernelSet<double>,kernelSet<double>},
-            {0,0,0,0}
-        };
-        set_callers[depth()][channels()-1](*this, s);
-    }
-    else
-    {
-        typedef void (*set_caller_t)(GpuMat& src, const Scalar& s, const GpuMat& mask);
-        static const set_caller_t set_callers[8][4] =
-        {
-            {NppSetMask<CV_8U, 1, nppiSet_8u_C1MR>::set,kernelSetMask<uchar>,kernelSetMask<uchar>,NppSetMask<CV_8U, 4, nppiSet_8u_C4MR>::set},
-            {kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>,kernelSetMask<schar>},
-            {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::set,kernelSetMask<ushort>,kernelSetMask<ushort>,NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::set},
-            {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::set,kernelSetMask<short>,kernelSetMask<short>,NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::set},
-            {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::set,kernelSetMask<int>,kernelSetMask<int>,NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::set},
-            {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::set,kernelSetMask<float>,kernelSetMask<float>,NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::set},
-            {kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>,kernelSetMask<double>},
-            {0,0,0,0}
-        };
-        set_callers[depth()][channels()-1](*this, s, mask);
-    }
-
-    return *this;
-}
-
-
-GpuMat cv::gpu::GpuMat::reshape(int new_cn, int new_rows) const
-{
-    GpuMat hdr = *this;
-
-    int cn = channels();
-    if( new_cn == 0 )
-        new_cn = cn;
-
-    int total_width = cols * cn;
-
-    if( (new_cn > total_width || total_width % new_cn != 0) && new_rows == 0 )
-        new_rows = rows * total_width / new_cn;
-
-    if( new_rows != 0 && new_rows != rows )
-    {
-        int total_size = total_width * rows;
-        if( !isContinuous() )
-            CV_Error( CV_BadStep, "The matrix is not continuous, thus its number of rows can not be changed" );
-
-        if( (unsigned)new_rows > (unsigned)total_size )
-            CV_Error( CV_StsOutOfRange, "Bad new number of rows" );
-
-        total_width = total_size / new_rows;
-
-        if( total_width * new_rows != total_size )
-            CV_Error( CV_StsBadArg, "The total number of matrix elements is not divisible by the new number of rows" );
-
-        hdr.rows = new_rows;
-        hdr.step = total_width * elemSize1();
-    }
-
-    int new_width = total_width / new_cn;
-
-    if( new_width * new_cn != total_width )
-        CV_Error( CV_BadNumChannels, "The total width is not divisible by the new number of channels" );
-
-    hdr.cols = new_width;
-    hdr.flags = (hdr.flags & ~CV_MAT_CN_MASK) | ((new_cn-1) << CV_CN_SHIFT);
-    return hdr;
-}
-
-void cv::gpu::GpuMat::create(int _rows, int _cols, int _type)
-{
-    _type &= TYPE_MASK;
-    if( rows == _rows && cols == _cols && type() == _type && data )
-        return;
-    if( data )
-        release();
-    CV_DbgAssert( _rows >= 0 && _cols >= 0 );
-    if( _rows > 0 && _cols > 0 )
-    {
-        flags = Mat::MAGIC_VAL + _type;
-        rows = _rows;
-        cols = _cols;
-
-        size_t esz = elemSize();
-
-        void *dev_ptr;
-        cudaSafeCall( cudaMallocPitch(&dev_ptr, &step, esz * cols, rows) );
-
-        // Single row must be continuous
-        if (rows == 1)
-            step = esz * cols;
-
-        if (esz * cols == step)
-            flags |= Mat::CONTINUOUS_FLAG;
-
-        int64 _nettosize = (int64)step*rows;
-        size_t nettosize = (size_t)_nettosize;
-
-        datastart = data = (uchar*)dev_ptr;
-        dataend = data + nettosize;
-
-        refcount = (int*)fastMalloc(sizeof(*refcount));
-        *refcount = 1;
-    }
-}
-
-void cv::gpu::GpuMat::release()
-{
-    if( refcount && CV_XADD(refcount, -1) == 1 )
-    {
-        fastFree(refcount);
-        cudaSafeCall( cudaFree(datastart) );
-    }
-    data = datastart = dataend = 0;
-    step = rows = cols = 0;
-    refcount = 0;
-}
-
-void cv::gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
-{
-    int area = rows * cols;
-    if (!m.isContinuous() || m.type() != type || m.size().area() != area)
-        m.create(1, area, type);
-    m = m.reshape(0, rows);
-}
-
-void cv::gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
-{
-    if (m.type() == type && m.rows >= rows && m.cols >= cols)
-        return;
-    m.create(rows, cols, type);
-}
-
-
-///////////////////////////////////////////////////////////////////////
-//////////////////////////////// CudaMem //////////////////////////////
-///////////////////////////////////////////////////////////////////////
-
 bool cv::gpu::CudaMem::canMapHostMemory()
 {
     cudaDeviceProp prop;
diff --git a/modules/gpu/src/matrix_reductions.cpp b/modules/gpu/src/matrix_reductions.cpp
index a2b4836924..04ed2c1d7c 100644
--- a/modules/gpu/src/matrix_reductions.cpp
+++ b/modules/gpu/src/matrix_reductions.cpp
@@ -116,7 +116,7 @@ void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev)
 
     DeviceBuffer dbuf(2);
 
-    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), src.step, sz, dbuf, (double*)dbuf + 1) );
+    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), sz, dbuf, (double*)dbuf + 1) );
 
     cudaSafeCall( cudaDeviceSynchronize() );
     
@@ -177,7 +177,7 @@ double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
 
     DeviceBuffer dbuf;
 
-    nppSafeCall( npp_norm_diff_func[funcIdx](src1.ptr<Npp8u>(), src1.step, src2.ptr<Npp8u>(), src2.step, sz, dbuf) );
+    nppSafeCall( npp_norm_diff_func[funcIdx](src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), sz, dbuf) );
 
     cudaSafeCall( cudaDeviceSynchronize() );
     
@@ -409,7 +409,7 @@ void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const Gp
     double maxVal_; if (!maxVal) maxVal = &maxVal_;
     
     Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, src.elemSize(), buf_size.width, buf_size.height);
+    getBufSizeRequired(src.cols, src.rows, static_cast<int>(src.elemSize()), buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
 
     if (mask.empty())
@@ -510,7 +510,7 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
     int maxLoc_[2];
 
     Size valbuf_size, locbuf_size;
-    getBufSizeRequired(src.cols, src.rows, src.elemSize(), valbuf_size.width, 
+    getBufSizeRequired(src.cols, src.rows, static_cast<int>(src.elemSize()), valbuf_size.width, 
                        valbuf_size.height, locbuf_size.width, locbuf_size.height);
     ensureSizeIsEnough(valbuf_size, CV_8U, valBuf);
     ensureSizeIsEnough(locbuf_size, CV_8U, locBuf);
diff --git a/modules/gpu/src/mssegmentation.cpp b/modules/gpu/src/mssegmentation.cpp
index fd62f432cb..609fdda7c8 100644
--- a/modules/gpu/src/mssegmentation.cpp
+++ b/modules/gpu/src/mssegmentation.cpp
@@ -227,8 +227,6 @@ inline int dist2(const cv::Vec2s& lhs, const cv::Vec2s& rhs)
 
 void cv::gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria)
 {
-    CV_Assert(TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12));
-
     CV_Assert(src.type() == CV_8UC4);
     const int nrows = src.rows;
     const int ncols = src.cols;
diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
index 03ecb57ec0..e0c766a3b6 100644
--- a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
+++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
@@ -1096,7 +1096,7 @@ NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImag
     NCVVectorReuse<Ncv32u> d_vecPixelMask(d_pixelMask.getSegment(), anchorsRoi.height * d_pixelMask.stride());
     ncvAssertReturn(d_vecPixelMask.isMemReused(), NCV_ALLOCATOR_BAD_REUSE);
 
-    NCVVectorAlloc<Ncv32u> d_vecPixelMaskTmp(gpuAllocator, d_vecPixelMask.length());
+    NCVVectorAlloc<Ncv32u> d_vecPixelMaskTmp(gpuAllocator, static_cast<Ncv32u>(d_vecPixelMask.length()));
     ncvAssertReturn(d_vecPixelMaskTmp.isMemAllocated(), NCV_ALLOCATOR_BAD_ALLOC);
 
     NCVVectorAlloc<Ncv32u> hp_pool32u(cpuAllocator, 2);
@@ -1120,7 +1120,7 @@ NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImag
     NCVVector<Ncv32u> *d_ptrNowTmp = &d_vecPixelMaskTmp;
 
     Ncv32u szNppCompactTmpBuf;
-    nppsStCompactGetSize_32u(d_vecPixelMask.length(), &szNppCompactTmpBuf, devProp);
+    nppsStCompactGetSize_32u(static_cast<Ncv32u>(d_vecPixelMask.length()), &szNppCompactTmpBuf, devProp);
     if (bDoAtomicCompaction)
     {
         szNppCompactTmpBuf = 0;
@@ -1206,7 +1206,7 @@ NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImag
                                         gridInit, blockInit, cuStream,
                                         d_ptrNowData->ptr(),
                                         d_ptrNowTmp->ptr(),
-                                        d_vecPixelMask.length(), d_pixelMask.stride(),
+                                        static_cast<Ncv32u>(d_vecPixelMask.length()), d_pixelMask.stride(),
                                         anchorsRoi, pixelStep);
         ncvAssertCUDAReturn(cudaGetLastError(), NCV_CUDA_ERROR);
 
@@ -1221,7 +1221,7 @@ NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImag
         else
         {
             NCVStatus nppSt;
-            nppSt = nppsStCompact_32u(d_ptrNowTmp->ptr(), d_vecPixelMask.length(),
+            nppSt = nppsStCompact_32u(d_ptrNowTmp->ptr(), static_cast<Ncv32u>(d_vecPixelMask.length()),
                                       d_ptrNowData->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
                                       d_tmpBufCompact.ptr(), szNppCompactTmpBuf, devProp);
             ncvAssertReturn(nppSt == NPPST_SUCCESS, NCV_NPP_ERROR);
@@ -1276,7 +1276,7 @@ NCVStatus ncvApplyHaarClassifierCascade_device(NCVMatrix<Ncv32u> &d_integralImag
         else
         {
             NCVStatus nppSt;
-            nppSt = nppsStCompact_32u(d_ptrNowData->ptr(), d_vecPixelMask.length(),
+            nppSt = nppsStCompact_32u(d_ptrNowData->ptr(), static_cast<Ncv32u>(d_vecPixelMask.length()),
                                       d_ptrNowTmp->ptr(), hp_numDet, OBJDET_MASK_ELEMENT_INVALID_32U,
                                       d_tmpBufCompact.ptr(), szNppCompactTmpBuf, devProp);
             ncvAssertReturnNcvStat(nppSt);
@@ -1783,7 +1783,7 @@ NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
             detectionsOnThisScale,
             d_hypothesesIntermediate,
             dstNumRects,
-            d_hypothesesIntermediate.length(),
+            static_cast<Ncv32u>(d_hypothesesIntermediate.length()),
             haar.ClassifierSize.width,
             haar.ClassifierSize.height,
             (Ncv32f)scale,
@@ -1880,7 +1880,7 @@ NCVStatus ncvDetectObjectsMultiScale_device(NCVMatrix<Ncv8u> &d_srcImg,
         if (dstNumRects > d_dstRects.length())
         {
             ncvRetCode = NCV_WARNING_HAAR_DETECTIONS_VECTOR_OVERFLOW;
-            dstNumRects = d_dstRects.length();
+            dstNumRects = static_cast<Ncv32u>(d_dstRects.length());
         }
 
         if (dstNumRects != 0)
diff --git a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
index f7cdfc6887..b0772d6359 100644
--- a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
+++ b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
@@ -457,7 +457,7 @@ NCVStatus nppiStIntegralGetSize_8u32u(NcvSize32u roiSize, Ncv32u *pBufsize, cuda
     ncvAssertReturn(pBufsize != NULL, NPPST_NULL_POINTER_ERROR);
     ncvAssertReturn(roiSize.width > 0 && roiSize.height > 0, NPPST_INVALID_ROI);
 
-    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator gpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertReturn(gpuCounter.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvIntegralImage_device((Ncv8u*)NULL, roiSize.width,
@@ -475,7 +475,7 @@ NCVStatus nppiStIntegralGetSize_32f32f(NcvSize32u roiSize, Ncv32u *pBufsize, cud
     ncvAssertReturn(pBufsize != NULL, NPPST_NULL_POINTER_ERROR);
     ncvAssertReturn(roiSize.width > 0 && roiSize.height > 0, NPPST_INVALID_ROI);
 
-    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator gpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertReturn(gpuCounter.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvIntegralImage_device((Ncv32f*)NULL, roiSize.width * sizeof(Ncv32f),
@@ -493,7 +493,7 @@ NCVStatus nppiStSqrIntegralGetSize_8u64u(NcvSize32u roiSize, Ncv32u *pBufsize, c
     ncvAssertReturn(pBufsize != NULL, NPPST_NULL_POINTER_ERROR);
     ncvAssertReturn(roiSize.width > 0 && roiSize.height > 0, NPPST_INVALID_ROI);
 
-    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator gpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertReturn(gpuCounter.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvSquaredIntegralImage_device(NULL, roiSize.width,
@@ -511,7 +511,7 @@ NCVStatus nppiStIntegral_8u32u_C1R(Ncv8u *d_src, Ncv32u srcStep,
                                    NcvSize32u roiSize, Ncv8u *pBuffer,
                                    Ncv32u bufSize, cudaDeviceProp &devProp)
 {
-    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, devProp.textureAlignment, pBuffer);
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, static_cast<Ncv32u>(devProp.textureAlignment), pBuffer);
     ncvAssertReturn(gpuAllocator.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvIntegralImage_device(d_src, srcStep, d_dst, dstStep, roiSize, gpuAllocator);
@@ -526,7 +526,7 @@ NCVStatus nppiStIntegral_32f32f_C1R(Ncv32f *d_src, Ncv32u srcStep,
                                     NcvSize32u roiSize, Ncv8u *pBuffer,
                                     Ncv32u bufSize, cudaDeviceProp &devProp)
 {
-    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, devProp.textureAlignment, pBuffer);
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, static_cast<Ncv32u>(devProp.textureAlignment), pBuffer);
     ncvAssertReturn(gpuAllocator.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvIntegralImage_device(d_src, srcStep, d_dst, dstStep, roiSize, gpuAllocator);
@@ -541,7 +541,7 @@ NCVStatus nppiStSqrIntegral_8u64u_C1R(Ncv8u *d_src, Ncv32u srcStep,
                                       NcvSize32u roiSize, Ncv8u *pBuffer,
                                       Ncv32u bufSize, cudaDeviceProp &devProp)
 {
-    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, devProp.textureAlignment, pBuffer);
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, static_cast<Ncv32u>(devProp.textureAlignment), pBuffer);
     ncvAssertReturn(gpuAllocator.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = ncvSquaredIntegralImage_device(d_src, srcStep, d_dst, dstStep, roiSize, gpuAllocator);
@@ -1506,7 +1506,7 @@ NCVStatus nppsStCompactGetSize_32u(Ncv32u srcLen, Ncv32u *pBufsize, cudaDevicePr
         return NPPST_SUCCESS;
     }
 
-    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator gpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertReturn(gpuCounter.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = compactVector_32u_device(NULL, srcLen, NULL, NULL, 0xC001C0DE,
@@ -1535,7 +1535,7 @@ NCVStatus nppsStCompact_32u(Ncv32u *d_src, Ncv32u srcLen,
                             Ncv32u elemRemove, Ncv8u *pBuffer,
                             Ncv32u bufSize, cudaDeviceProp &devProp)
 {
-    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, devProp.textureAlignment, pBuffer);
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, bufSize, static_cast<Ncv32u>(devProp.textureAlignment), pBuffer);
     ncvAssertReturn(gpuAllocator.isInitialized(), NPPST_MEM_INTERNAL_ERROR);
 
     NCVStatus ncvStat = compactVector_32u_device(d_src, srcLen, d_dst, p_dstLen, elemRemove,
diff --git a/modules/gpu/src/nvidia/core/NCV.cu b/modules/gpu/src/nvidia/core/NCV.cu
index 3078219c2e..6b55740aba 100644
--- a/modules/gpu/src/nvidia/core/NCV.cu
+++ b/modules/gpu/src/nvidia/core/NCV.cu
@@ -355,7 +355,7 @@ NCVStatus NCVMemStackAllocator::alloc(NCVMemSegment &seg, size_t size)
     seg.clear();
     ncvAssertReturn(isInitialized(), NCV_ALLOCATOR_BAD_ALLOC);
 
-    size = alignUp(size, this->_alignment);
+    size = alignUp(static_cast<Ncv32u>(size), this->_alignment);
     this->currentSize += size;
     this->_maxSize = std::max(this->_maxSize, this->currentSize);
 
@@ -464,7 +464,7 @@ NCVStatus NCVMemNativeAllocator::alloc(NCVMemSegment &seg, size_t size)
         break;
     }
 
-    this->currentSize += alignUp(size, this->_alignment);
+    this->currentSize += alignUp(static_cast<Ncv32u>(size), this->_alignment);
     this->_maxSize = std::max(this->_maxSize, this->currentSize);
 
     seg.begin.memtype = this->_memType;
@@ -480,8 +480,8 @@ NCVStatus NCVMemNativeAllocator::dealloc(NCVMemSegment &seg)
     ncvAssertReturn(seg.begin.memtype == this->_memType, NCV_ALLOCATOR_BAD_DEALLOC);
     ncvAssertReturn(seg.begin.ptr != NULL, NCV_ALLOCATOR_BAD_DEALLOC);
 
-    ncvAssertReturn(currentSize >= alignUp(seg.size, this->_alignment), NCV_ALLOCATOR_BAD_DEALLOC);
-    currentSize -= alignUp(seg.size, this->_alignment);
+    ncvAssertReturn(currentSize >= alignUp(static_cast<Ncv32u>(seg.size), this->_alignment), NCV_ALLOCATOR_BAD_DEALLOC);
+    currentSize -= alignUp(static_cast<Ncv32u>(seg.size), this->_alignment);
 
     switch (this->_memType)
     {
diff --git a/modules/gpu/src/nvidia/core/NCV.hpp b/modules/gpu/src/nvidia/core/NCV.hpp
index f51390c964..f310e14c4b 100644
--- a/modules/gpu/src/nvidia/core/NCV.hpp
+++ b/modules/gpu/src/nvidia/core/NCV.hpp
@@ -49,7 +49,7 @@
 #endif
 
 #ifdef _WIN32
-	#define WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
 #endif
 
 #include <cuda_runtime.h>
diff --git a/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp b/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
index e6adbe6ac1..45185deb49 100644
--- a/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp
@@ -43,8 +43,8 @@
 #ifndef __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 #define __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 
-#include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vecmath.hpp"
+#include "saturate_cast.hpp"
+#include "vec_traits.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -72,64 +72,53 @@ namespace cv { namespace gpu { namespace device
             return -last <= mini && maxi <= 2 * last;
         }
 
-    private:
         int last;
     };
 
-
-    template <typename D>
-    struct BrdRowReflect101: BrdReflect101
+    template <typename D> struct BrdRowReflect101 : BrdReflect101
     {
         explicit BrdRowReflect101(int len): BrdReflect101(len) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
             return saturate_cast<D>(data[idx_low(i)]);
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
             return saturate_cast<D>(data[idx_high(i)]);
         }
     };
 
-
-    template <typename D>
-    struct BrdColReflect101: BrdReflect101
+    template <typename D> struct BrdColReflect101 : BrdReflect101
     {
-        BrdColReflect101(int len, int step): BrdReflect101(len), step(step) {}
+        BrdColReflect101(int len, size_t step): BrdReflect101(len), step(step) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
-            return saturate_cast<D>(data[idx_low(i) * step]);
+            return saturate_cast<D>(*(const D*)((const char*)data + idx_low(i)*step));
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
-            return saturate_cast<D>(data[idx_high(i) * step]);
+            return saturate_cast<D>(*(const D*)((const char*)data + idx_high(i)*step));
         }
 
-    private:
-        int step;
+        size_t step;
     };
 
-
     struct BrdReplicate
     {
         explicit BrdReplicate(int len): last(len - 1) {}
 
         __device__ __forceinline__ int idx_low(int i) const
         {
-            return max(i, 0);
+            return ::max(i, 0);
         }
 
         __device__ __forceinline__ int idx_high(int i) const 
         {
-            return min(i, last);
+            return ::min(i, last);
         }
 
         __device__ __forceinline__ int idx(int i) const
@@ -142,64 +131,52 @@ namespace cv { namespace gpu { namespace device
             return true;
         }
 
-    private:
         int last;
     };
 
-
-    template <typename D>
-    struct BrdRowReplicate: BrdReplicate
+    template <typename D> struct BrdRowReplicate : BrdReplicate
     {
         explicit BrdRowReplicate(int len): BrdReplicate(len) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
             return saturate_cast<D>(data[idx_low(i)]);
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
             return saturate_cast<D>(data[idx_high(i)]);
         }
     };
 
 
-    template <typename D>
-    struct BrdColReplicate: BrdReplicate
+    template <typename D> struct BrdColReplicate : BrdReplicate
     {
-        BrdColReplicate(int len, int step): BrdReplicate(len), step(step) {}
+        BrdColReplicate(int len, size_t step): BrdReplicate(len), step(step) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
-            return saturate_cast<D>(data[idx_low(i) * step]);
+            return saturate_cast<D>(*(const D*)((const char*)data + idx_low(i)*step));
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
-            return saturate_cast<D>(data[idx_high(i) * step]);
+            return saturate_cast<D>(*(const D*)((const char*)data + idx_high(i)*step));
         }
 
-    private:
-        int step;
+        size_t step;
     };
 
-    template <typename D>
-    struct BrdRowConstant
+    template <typename D> struct BrdRowConstant
     {
         explicit BrdRowConstant(int len_, const D& val_ = VecTraits<D>::all(0)): len(len_), val(val_) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
             return i >= 0 ? saturate_cast<D>(data[i]) : val;
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
             return i < len ? saturate_cast<D>(data[i]) : val;
         }
@@ -209,26 +186,22 @@ namespace cv { namespace gpu { namespace device
             return true;
         }
 
-    private:
         int len;
         D val;
     };
 
-    template <typename D>
-    struct BrdColConstant
+    template <typename D> struct BrdColConstant
     {
-        BrdColConstant(int len_, int step_, const D& val_ = VecTraits<D>::all(0)): len(len_), step(step_), val(val_) {}
+        BrdColConstant(int len_, size_t step_, const D& val_ = VecTraits<D>::all(0)): len(len_), step(step_), val(val_) {}
 
-        template <typename T>
-        __device__ __forceinline__ D at_low(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_low(int i, const T* data) const 
         {
-            return i >= 0 ? saturate_cast<D>(data[i * step]) : val;
+            return i >= 0 ? saturate_cast<D>(*(const D*)((const char*)data + i*step)) : val;
         }
 
-        template <typename T>
-        __device__ __forceinline__ D at_high(int i, const T* data) const 
+        template <typename T> __device__ __forceinline__ D at_high(int i, const T* data) const 
         {
-            return i < len ? saturate_cast<D>(data[i * step]) : val;
+            return i < len ? saturate_cast<D>(*(const D*)((const char*)data + i*step)) : val;
         }
 
         bool is_range_safe(int mini, int maxi) const 
@@ -236,11 +209,25 @@ namespace cv { namespace gpu { namespace device
             return true;
         }
 
-    private:
         int len;
-        int step;
+        size_t step;
         D val;
     };
+
+    template <typename OutT> struct BrdConstant
+    {
+        BrdConstant(int w, int h, const OutT &val = VecTraits<OutT>::all(0)) : w(w), h(h), val(val) {}
+
+        __device__ __forceinline__ OutT at(int x, int y, const uchar* data, int step) const
+        {
+            if (x >= 0 && x <= w - 1 && y >= 0 && y <= h - 1)
+                return ((const OutT*)(data + y * step))[x];
+            return val;
+        }
+
+        int w, h;
+        OutT val;
+    };
 }}}
 
 #endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/color.hpp b/modules/gpu/src/opencv2/gpu/device/color.hpp
new file mode 100644
index 0000000000..d620ead481
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/color.hpp
@@ -0,0 +1,221 @@
+/*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 bpied warranties, including, but not limited to, the bpied
+// 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_GPU_COLOR_HPP__
+#define __OPENCV_GPU_COLOR_HPP__
+
+#include "detail/color.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    // All OPENCV_GPU_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements
+    // template <typename T> class ColorSpace1_to_ColorSpace2_traits
+    // {
+    //     typedef ... functor_type;
+    //     static __host__ __device__ functor_type create_functor();
+    // };
+
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_bgra, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgr_to_rgba, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_bgr, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(bgra_to_rgba, 4, 4, 2)
+    
+#undef OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr555, 3, 0, 5)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgr_to_bgr565, 3, 0, 6)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr555, 3, 2, 5)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgb_to_bgr565, 3, 2, 6)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr555, 4, 0, 5)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(bgra_to_bgr565, 4, 0, 6)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr555, 4, 2, 5)
+    OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(rgba_to_bgr565, 4, 2, 6)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgb, 3, 2, 5)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgb, 3, 2, 6)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgr, 3, 0, 5)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgr, 3, 0, 6)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_rgba, 4, 2, 5)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_rgba, 4, 2, 6)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr555_to_bgra, 4, 0, 5)
+    OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(bgr565_to_bgra, 4, 0, 6)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgr, 3)
+    OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(gray_to_bgra, 4)
+    
+#undef OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr555, 5)
+    OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(gray_to_bgr565, 6)
+
+#undef OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr555_to_gray, 5)
+    OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(bgr565_to_gray, 6)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgb_to_gray, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgr_to_gray, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(rgba_to_gray, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(bgra_to_gray, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgb_to_yuv4, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(rgba_to_yuv4, 4, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgr_to_yuv4, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(bgra_to_yuv4, 4, 4, 2)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgb, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_rgba, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgb, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_rgba, 4, 4, 0)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgr, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv_to_bgra, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgr, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(yuv4_to_bgra, 4, 4, 2)
+
+#undef OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgb_to_YCrCb4, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(rgba_to_YCrCb4, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgr_to_YCrCb4, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(bgra_to_YCrCb4, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_rgba, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_rgba, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgr, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb_to_bgra, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgr, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(YCrCb4_to_bgra, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgb_to_xyz4, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(rgba_to_xyz4, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgr_to_xyz4, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(bgra_to_xyz4, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_rgba, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_rgba, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgr, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgr, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz_to_bgra, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(xyz4_to_bgra, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgb_to_hsv4, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(rgba_to_hsv4, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgr_to_hsv4, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(bgra_to_hsv4, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_rgba, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_rgba, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgr, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv_to_bgra, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgr, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(hsv4_to_bgra, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgb_to_hls4, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(rgba_to_hls4, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgr_to_hls4, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(bgra_to_hls4, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS
+
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgb, 3, 3, 2)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_rgba, 3, 4, 2)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgb, 4, 3, 2)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_rgba, 4, 4, 2)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgr, 3, 3, 0)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls_to_bgra, 3, 4, 0)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgr, 4, 3, 0)
+    OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(hls4_to_bgra, 4, 4, 0)
+
+#undef OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS
+}}}
+
+#endif // __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp b/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
index 2602991c85..407aea2f93 100644
--- a/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp
@@ -44,6 +44,7 @@
 #define __OPENCV_GPU_DATAMOV_UTILS_HPP__
 
 #include "internal_shared.hpp"
+#include "utility.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -55,49 +56,40 @@ namespace cv { namespace gpu { namespace device
             __device__ __forceinline__ static void Load(const T* ptr, int offset, T& val)  { val = ptr[offset];  }
         };
             
-    #else // __CUDA_ARCH__ >= 200
-
-        #if defined(_WIN64) || defined(__LP64__)		
-            // 64-bit register modifier for inlined asm
-            #define _OPENCV_ASM_PTR_ "l"
-        #else	
-            // 32-bit register modifier for inlined asm
-            #define _OPENCV_ASM_PTR_ "r"
-        #endif
+    #else // __CUDA_ARCH__ >= 200        
 
         template<class T> struct ForceGlob;
 
-        #define DEFINE_FORCE_GLOB(base_type, ptx_type, reg_mod)                                                   \
-        template <> struct ForceGlob<base_type>                                                                   \
-        {                                                                                                         \
-            __device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val)         \
-            {                                                                                                     \
-                asm("ld.global."#ptx_type" %0, [%1];" : "="#reg_mod(val) : _OPENCV_ASM_PTR_(ptr + offset));       \
-            }                                                                                                     \
-        };
-        #define DEFINE_FORCE_GLOB_B(base_type, ptx_type)                                                                          \
-        template <> struct ForceGlob<base_type>                                                                                   \
-        {                                                                                                                         \
-            __device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val)                         \
-            {                                                                                                                     \
-                asm("ld.global."#ptx_type" %0, [%1];" : "=r"(*reinterpret_cast<uint*>(&val)) : _OPENCV_ASM_PTR_(ptr + offset));   \
-            }                                                                                                                     \
-        };
-        
-        DEFINE_FORCE_GLOB_B(uchar,  u8)
-        DEFINE_FORCE_GLOB_B(schar,  s8)
-        DEFINE_FORCE_GLOB_B(char,   b8)
-        DEFINE_FORCE_GLOB  (ushort, u16, h)
-        DEFINE_FORCE_GLOB  (short,  s16, h)
-        DEFINE_FORCE_GLOB  (uint,   u32, r)
-        DEFINE_FORCE_GLOB  (int,    s32, r)	
-        DEFINE_FORCE_GLOB  (float,  f32, f)	
-        DEFINE_FORCE_GLOB  (double, f64, d)	
-            
+        #define OPENCV_GPU_DEFINE_FORCE_GLOB(base_type, ptx_type, reg_mod) \
+            template <> struct ForceGlob<base_type> \
+            { \
+                __device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
+                { \
+                    asm("ld.global."#ptx_type" %0, [%1];" : "="#reg_mod(val) : OPENCV_GPU_ASM_PTR(ptr + offset)); \
+                } \
+            };
 
-    #undef DEFINE_FORCE_GLOB
-    #undef DEFINE_FORCE_GLOB_B
-    #undef _OPENCV_ASM_PTR_
+        #define OPENCV_GPU_DEFINE_FORCE_GLOB_B(base_type, ptx_type) \
+            template <> struct ForceGlob<base_type> \
+            { \
+                __device__ __forceinline__ static void Load(const base_type* ptr, int offset, base_type& val) \
+                { \
+                    asm("ld.global."#ptx_type" %0, [%1];" : "=r"(*reinterpret_cast<uint*>(&val)) : OPENCV_GPU_ASM_PTR(ptr + offset)); \
+                } \
+            };
+        
+        OPENCV_GPU_DEFINE_FORCE_GLOB_B(uchar,  u8)
+        OPENCV_GPU_DEFINE_FORCE_GLOB_B(schar,  s8)
+        OPENCV_GPU_DEFINE_FORCE_GLOB_B(char,   b8)
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (ushort, u16, h)
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (short,  s16, h)
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (uint,   u32, r)
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (int,    s32, r)	
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (float,  f32, f)	
+        OPENCV_GPU_DEFINE_FORCE_GLOB  (double, f64, d)	            
+
+    #undef OPENCV_GPU_DEFINE_FORCE_GLOB
+    #undef OPENCV_GPU_DEFINE_FORCE_GLOB_B
         
     #endif // __CUDA_ARCH__ >= 200
 }}}
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/color.hpp b/modules/gpu/src/opencv2/gpu/device/detail/color.hpp
new file mode 100644
index 0000000000..748769e16a
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/detail/color.hpp
@@ -0,0 +1,1037 @@
+/*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 bpied warranties, including, but not limited to, the bpied
+// 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_GPU_COLOR_DETAIL_HPP__
+#define __OPENCV_GPU_COLOR_DETAIL_HPP__
+
+#include "../vec_traits.hpp"
+#include "../saturate_cast.hpp"
+#include "../limits.hpp"
+#include "../functional.hpp"
+
+#ifndef CV_DESCALE
+    #define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))
+#endif
+
+namespace cv { namespace gpu { namespace device
+{
+    namespace detail
+    {
+        template<typename T> struct ColorChannel
+        {
+            typedef float worktype_f;
+            static __device__ __forceinline__ T max() { return numeric_limits<T>::max(); }
+            static __device__ __forceinline__ T half() { return (T)(max()/2 + 1); }
+        };
+        template<> struct ColorChannel<float>
+        {
+            typedef float worktype_f;
+            static __device__ __forceinline__ float max() { return 1.f; }
+            static __device__ __forceinline__ float half() { return 0.5f; }
+        };
+
+        template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 3>::vec_type& vec, T val)
+        {
+        }
+        template <typename T> static __device__ __forceinline__ void setAlpha(typename TypeVec<T, 4>::vec_type& vec, T val)
+        {
+            vec.w = val;
+        }
+        template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 3>::vec_type& vec)
+        {
+            return ColorChannel<T>::max();
+        }
+        template <typename T> static __device__ __forceinline__ T getAlpha(const typename TypeVec<T, 4>::vec_type& vec)
+        {
+            return vec.w;
+        }
+
+        enum
+        {
+            yuv_shift  = 14,
+            xyz_shift  = 12,
+            R2Y        = 4899,
+            G2Y        = 9617,
+            B2Y        = 1868,
+            BLOCK_SIZE = 256
+        };
+    }
+
+////////////////// Various 3/4-channel to 3/4-channel RGB transformations /////////////////
+
+    namespace detail
+    {
+        template <typename T, typename D, int bidx> struct RGB2RGB : public unary_function<T, D>
+        {
+            __device__ D operator()(const T& src) const
+            {
+                D dst;
+                dst.x = (&src.x)[bidx];
+                dst.y = src.y;
+                dst.z = (&src.x)[bidx^2];
+                setAlpha(dst, getAlpha<typename VecTraits<T>::elem_type>(src));
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+/////////// Transforming 16-bit (565 or 555) RGB to/from 24/32-bit (888[8]) RGB //////////
+
+    namespace detail
+    {
+        template <int GREEN_BITS, int bidx> struct RGB2RGB5x5Converter;
+        template<int bidx> struct RGB2RGB5x5Converter<6, bidx> 
+        {
+            template <typename T> static __device__ __forceinline__ ushort cvt(const T& src)
+            {
+                return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~3) << 3) | (((&src.x)[bidx^2] & ~7) << 8));
+            }
+        };
+        template<int bidx> struct RGB2RGB5x5Converter<5, bidx> 
+        {
+            static __device__ __forceinline__ ushort cvt(const uchar3& src)
+            {
+                return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7));
+            }
+            static __device__ __forceinline__ ushort cvt(const uchar4& src)
+            {
+                return (ushort)(((&src.x)[bidx] >> 3) | ((src.y & ~7) << 2) | (((&src.x)[bidx^2] & ~7) << 7) | (src.w ? 0x8000 : 0));
+            }
+        };
+
+        template<typename T, int bidx, int GREEN_BITS> struct RGB2RGB5x5 : public unary_function<T, ushort>
+        {
+            __device__ __forceinline__ ushort operator()(const T& src) const
+            {
+                return RGB2RGB5x5Converter<GREEN_BITS, bidx>::cvt(src);
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2RGB5x5_TRAITS(name, scn, bidx, green_bits) \
+    struct name ## _traits \
+    { \
+        typedef detail::RGB2RGB5x5<uchar ## scn, bidx, green_bits> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2RGB5x5<uchar ## scn, bidx, green_bits>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        template <int GREEN_BITS, int bidx> struct RGB5x52RGBConverter;    
+        template <int bidx> struct RGB5x52RGBConverter<5, bidx>
+        {
+            template <typename D> static __device__ void cvt(uint src, D& dst)
+            {            
+                (&dst.x)[bidx] = (uchar)(src << 3);
+                dst.y = (uchar)((src >> 2) & ~7);
+                (&dst.x)[bidx ^ 2] = (uchar)((src >> 7) & ~7);
+                setAlpha(dst, (uchar)(src & 0x8000 ? 255 : 0));
+            }
+        };
+        template <int bidx> struct RGB5x52RGBConverter<6, bidx>
+        {
+            template <typename D>
+            static __device__ void cvt(uint src, D& dst)
+            {            
+                (&dst.x)[bidx] = (uchar)(src << 3);
+                dst.y = (uchar)((src >> 3) & ~3);
+                (&dst.x)[bidx ^ 2] = (uchar)((src >> 8) & ~7);
+                setAlpha(dst, (uchar)(255));
+            }
+        };
+
+        template <typename D, int bidx, int GREEN_BITS> struct RGB5x52RGB : public unary_function<ushort, D>
+        {
+            __device__ __forceinline__ D operator()(ushort src) const
+            {
+                D dst;
+                RGB5x52RGBConverter<GREEN_BITS, bidx>::cvt((uint)src, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB5x52RGB_TRAITS(name, dcn, bidx, green_bits) \
+    struct name ## _traits \
+    { \
+        typedef detail::RGB5x52RGB<uchar ## dcn, bidx, green_bits> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB5x52RGB<uchar ## dcn, bidx, green_bits>(); \
+        } \
+    };
+
+///////////////////////////////// Grayscale to Color ////////////////////////////////
+
+    namespace detail
+    {
+        template <typename T, typename D> struct Gray2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                dst.z = dst.y = dst.x = src;            
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_GRAY2RGB_TRAITS(name, dcn) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::Gray2RGB<T, typename TypeVec<T, dcn>::vec_type> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::Gray2RGB<T, typename TypeVec<T, dcn>::vec_type>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        template <int GREEN_BITS> struct Gray2RGB5x5Converter;
+        template<> struct Gray2RGB5x5Converter<6> 
+        {
+            static __device__ __forceinline__ ushort cvt(uint t)
+            {
+                return (ushort)((t >> 3) | ((t & ~3) << 3) | ((t & ~7) << 8));
+            }
+        };
+        template<> struct Gray2RGB5x5Converter<5> 
+        {
+            static __device__ __forceinline__ ushort cvt(uint t)
+            {
+                t >>= 3;
+                return (ushort)(t | (t << 5) | (t << 10));
+            }
+        };
+
+        template<int GREEN_BITS> struct Gray2RGB5x5 : public unary_function<uchar, ushort>
+        {
+            __device__ __forceinline__ ushort operator()(uchar src) const
+            {
+                return Gray2RGB5x5Converter<GREEN_BITS>::cvt((uint)src);
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_GRAY2RGB5x5_TRAITS(name, green_bits) \
+    struct name ## _traits \
+    { \
+        typedef detail::Gray2RGB5x5<green_bits> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::Gray2RGB5x5<green_bits>(); \
+        } \
+    };
+
+///////////////////////////////// Color to Grayscale ////////////////////////////////
+
+    namespace detail
+    {
+        template <int GREEN_BITS> struct RGB5x52GrayConverter;
+        template <> struct RGB5x52GrayConverter<6> 
+        {
+            static __device__ __forceinline__ uchar cvt(uint t)
+            {
+                return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 3) & 0xfc) * G2Y + ((t >> 8) & 0xf8) * R2Y, yuv_shift);
+            }
+        };
+        template <> struct RGB5x52GrayConverter<5> 
+        {
+            static __device__ __forceinline__ uchar cvt(uint t)
+            {
+                return (uchar)CV_DESCALE(((t << 3) & 0xf8) * B2Y + ((t >> 2) & 0xf8) * G2Y + ((t >> 7) & 0xf8) * R2Y, yuv_shift);
+            }
+        };   
+
+        template<int GREEN_BITS> struct RGB5x52Gray : public unary_function<ushort, uchar>
+        {
+            __device__ __forceinline__ uchar operator()(ushort src) const
+            {
+                return RGB5x52GrayConverter<GREEN_BITS>::cvt((uint)src);
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB5x52GRAY_TRAITS(name, green_bits) \
+    struct name ## _traits \
+    { \
+        typedef detail::RGB5x52Gray<green_bits> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB5x52Gray<green_bits>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        template <int bidx, typename T> static __device__ __forceinline__ T RGB2GrayConvert(const T* src)
+        {
+            return (T)CV_DESCALE((unsigned)(src[bidx] * B2Y + src[1] * G2Y + src[bidx^2] * R2Y), yuv_shift);
+        }
+        template <int bidx> static __device__ __forceinline__ float RGB2GrayConvert(const float* src)
+        {
+            return src[bidx] * 0.114f + src[1] * 0.587f + src[bidx^2] * 0.299f;
+        }
+
+        template <typename T, typename D, int bidx> struct RGB2Gray : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                return RGB2GrayConvert<bidx>(&src.x);
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2GRAY_TRAITS(name, scn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2Gray<typename TypeVec<T, scn>::vec_type, T, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2Gray<typename TypeVec<T, scn>::vec_type, T, bidx>(); \
+        } \
+    };
+
+///////////////////////////////////// RGB <-> YUV //////////////////////////////////////
+
+    namespace detail
+    {
+        __constant__ float c_RGB2YUVCoeffs_f[5] = { 0.114f, 0.587f, 0.299f, 0.492f, 0.877f };
+        __constant__ int   c_RGB2YUVCoeffs_i[5] = { B2Y, G2Y, R2Y, 8061, 14369 };
+
+        template <int bidx, typename T, typename D> static __device__ void RGB2YUVConvert(const T* src, D& dst)
+        {
+            const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
+
+            const int Y = CV_DESCALE(src[0] * c_RGB2YUVCoeffs_i[bidx^2] + src[1] * c_RGB2YUVCoeffs_i[1] + src[2] * c_RGB2YUVCoeffs_i[bidx], yuv_shift);
+            const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YUVCoeffs_i[3] + delta, yuv_shift);
+            const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YUVCoeffs_i[4] + delta, yuv_shift);
+
+            dst.x = saturate_cast<T>(Y);
+            dst.y = saturate_cast<T>(Cr);
+            dst.z = saturate_cast<T>(Cb);
+        }
+        template <int bidx, typename D> static __device__ __forceinline__ void RGB2YUVConvert(const float* src, D& dst)
+        {
+            dst.x = src[0] * c_RGB2YUVCoeffs_f[bidx^2] + src[1] * c_RGB2YUVCoeffs_f[1] + src[2] * c_RGB2YUVCoeffs_f[bidx];
+            dst.y = (src[bidx^2] - dst.x) * c_RGB2YUVCoeffs_f[3] + ColorChannel<float>::half();
+            dst.z = (src[bidx] - dst.x) * c_RGB2YUVCoeffs_f[4] + ColorChannel<float>::half();
+        }
+
+        template <typename T, typename D, int bidx> struct RGB2YUV : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator ()(const T& src) const
+            {
+                D dst;
+                RGB2YUVConvert<bidx>(&src.x, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2YUV_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2YUV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2YUV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        __constant__ float c_YUV2RGBCoeffs_f[5] = { 2.032f, -0.395f, -0.581f, 1.140f };
+        __constant__ int   c_YUV2RGBCoeffs_i[5] = { 33292, -6472, -9519, 18678 }; 
+
+        template <int bidx, typename T, typename D> static __device__ void YUV2RGBConvert(const T& src, D* dst)
+        {
+            const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[3], yuv_shift);
+            const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[1], yuv_shift);
+            const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YUV2RGBCoeffs_i[0], yuv_shift);
+
+            dst[bidx] = saturate_cast<D>(b);
+            dst[1] = saturate_cast<D>(g);
+            dst[bidx^2] = saturate_cast<D>(r);
+        }
+        template <int bidx, typename T> static __device__ __forceinline__ void YUV2RGBConvert(const T& src, float* dst)
+        {
+            dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[3];
+            dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[1];
+            dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YUV2RGBCoeffs_f[0];
+        }
+
+        template <typename T, typename D, int bidx> struct YUV2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator ()(const T& src) const
+            {
+                D dst;
+
+                YUV2RGBConvert<bidx>(src, &dst.x);
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_YUV2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::YUV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::YUV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+///////////////////////////////////// RGB <-> YCrCb //////////////////////////////////////
+    
+    namespace detail
+    {
+        __constant__ float c_RGB2YCrCbCoeffs_f[5] = {0.299f, 0.587f, 0.114f, 0.713f, 0.564f};
+        __constant__ int   c_RGB2YCrCbCoeffs_i[5] = {R2Y, G2Y, B2Y, 11682, 9241};
+        
+        template <int bidx, typename T, typename D> static __device__ void RGB2YCrCbConvert(const T* src, D& dst)
+        {
+            const int delta = ColorChannel<T>::half() * (1 << yuv_shift);
+
+            const int Y = CV_DESCALE(src[0] * c_RGB2YCrCbCoeffs_i[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_i[1] + src[2] * c_RGB2YCrCbCoeffs_i[bidx], yuv_shift);
+            const int Cr = CV_DESCALE((src[bidx^2] - Y) * c_RGB2YCrCbCoeffs_i[3] + delta, yuv_shift);
+            const int Cb = CV_DESCALE((src[bidx] - Y) * c_RGB2YCrCbCoeffs_i[4] + delta, yuv_shift);
+
+            dst.x = saturate_cast<T>(Y);
+            dst.y = saturate_cast<T>(Cr);
+            dst.z = saturate_cast<T>(Cb);
+        }
+        template <int bidx, typename D> static __device__ __forceinline__ void RGB2YCrCbConvert(const float* src, D& dst)
+        {
+            dst.x = src[0] * c_RGB2YCrCbCoeffs_f[bidx^2] + src[1] * c_RGB2YCrCbCoeffs_f[1] + src[2] * c_RGB2YCrCbCoeffs_f[bidx];
+            dst.y = (src[bidx^2] - dst.x) * c_RGB2YCrCbCoeffs_f[3] + ColorChannel<float>::half();
+            dst.z = (src[bidx] - dst.x) * c_RGB2YCrCbCoeffs_f[4] + ColorChannel<float>::half();
+        }
+
+        template <typename T, typename D, int bidx> struct RGB2YCrCb : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator ()(const T& src) const
+            {
+                D dst;
+                RGB2YCrCbConvert<bidx>(&src.x, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2YCrCb_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2YCrCb<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2YCrCb<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        __constant__ float c_YCrCb2RGBCoeffs_f[5] = {1.403f, -0.714f, -0.344f, 1.773f};
+        __constant__ int   c_YCrCb2RGBCoeffs_i[5] = {22987, -11698, -5636, 29049};
+
+        template <int bidx, typename T, typename D> static __device__ void YCrCb2RGBConvert(const T& src, D* dst)
+        {
+            const int b = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[3], yuv_shift);
+            const int g = src.x + CV_DESCALE((src.z - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[2] + (src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[1], yuv_shift);
+            const int r = src.x + CV_DESCALE((src.y - ColorChannel<D>::half()) * c_YCrCb2RGBCoeffs_i[0], yuv_shift);
+
+            dst[bidx] = saturate_cast<D>(b);
+            dst[1] = saturate_cast<D>(g);
+            dst[bidx^2] = saturate_cast<D>(r);
+        }
+        template <int bidx, typename T> __device__ __forceinline__ void YCrCb2RGBConvert(const T& src, float* dst)
+        {
+            dst[bidx] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[3];
+            dst[1] = src.x + (src.z - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[2] + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[1];
+            dst[bidx^2] = src.x + (src.y - ColorChannel<float>::half()) * c_YCrCb2RGBCoeffs_f[0];
+        }
+
+        template <typename T, typename D, int bidx> struct YCrCb2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator ()(const T& src) const
+            {
+                D dst;
+
+                YCrCb2RGBConvert<bidx>(src, &dst.x);
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_YCrCb2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::YCrCb2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::YCrCb2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+////////////////////////////////////// RGB <-> XYZ ///////////////////////////////////////
+
+    namespace detail
+    {
+        __constant__ float c_RGB2XYZ_D65f[9] = { 0.412453f, 0.357580f, 0.180423f, 0.212671f, 0.715160f, 0.072169f, 0.019334f, 0.119193f, 0.950227f };
+        __constant__ int   c_RGB2XYZ_D65i[9] = { 1689, 1465, 739, 871, 2929, 296, 79, 488, 3892 };
+
+        template <int bidx, typename T, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const T* src, D& dst)
+        {
+            dst.x = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[0] + src[1] * c_RGB2XYZ_D65i[1] + src[bidx] * c_RGB2XYZ_D65i[2], xyz_shift));
+            dst.y = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[3] + src[1] * c_RGB2XYZ_D65i[4] + src[bidx] * c_RGB2XYZ_D65i[5], xyz_shift));
+            dst.z = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[6] + src[1] * c_RGB2XYZ_D65i[7] + src[bidx] * c_RGB2XYZ_D65i[8], xyz_shift));
+        }
+        template <int bidx, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const float* src, D& dst)
+        {
+            dst.x = src[bidx^2] * c_RGB2XYZ_D65f[0] + src[1] * c_RGB2XYZ_D65f[1] + src[bidx] * c_RGB2XYZ_D65f[2];
+            dst.y = src[bidx^2] * c_RGB2XYZ_D65f[3] + src[1] * c_RGB2XYZ_D65f[4] + src[bidx] * c_RGB2XYZ_D65f[5];
+            dst.z = src[bidx^2] * c_RGB2XYZ_D65f[6] + src[1] * c_RGB2XYZ_D65f[7] + src[bidx] * c_RGB2XYZ_D65f[8];
+        }
+
+        template <typename T, typename D, int bidx> struct RGB2XYZ : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                RGB2XYZConvert<bidx>(&src.x, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2XYZ_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2XYZ<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2XYZ<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        __constant__ float c_XYZ2sRGB_D65f[9] = { 3.240479f, -1.53715f, -0.498535f, -0.969256f, 1.875991f, 0.041556f, 0.055648f, -0.204043f, 1.057311f };
+        __constant__ int   c_XYZ2sRGB_D65i[9] = { 13273, -6296, -2042, -3970, 7684, 170, 228, -836, 4331 };
+
+        template <int bidx, typename T, typename D> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, D* dst)
+        {
+            dst[bidx^2] = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[0] + src.y * c_XYZ2sRGB_D65i[1] + src.z * c_XYZ2sRGB_D65i[2], xyz_shift));
+	        dst[1]      = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[3] + src.y * c_XYZ2sRGB_D65i[4] + src.z * c_XYZ2sRGB_D65i[5], xyz_shift));
+	        dst[bidx]   = saturate_cast<D>(CV_DESCALE(src.x * c_XYZ2sRGB_D65i[6] + src.y * c_XYZ2sRGB_D65i[7] + src.z * c_XYZ2sRGB_D65i[8], xyz_shift));
+        }
+        template <int bidx, typename T> static __device__ __forceinline__ void XYZ2RGBConvert(const T& src, float* dst)
+        {
+            dst[bidx^2] = src.x * c_XYZ2sRGB_D65f[0] + src.y * c_XYZ2sRGB_D65f[1] + src.z * c_XYZ2sRGB_D65f[2];
+	        dst[1]      = src.x * c_XYZ2sRGB_D65f[3] + src.y * c_XYZ2sRGB_D65f[4] + src.z * c_XYZ2sRGB_D65f[5];
+	        dst[bidx]   = src.x * c_XYZ2sRGB_D65f[6] + src.y * c_XYZ2sRGB_D65f[7] + src.z * c_XYZ2sRGB_D65f[8];
+        }
+
+        template <typename T, typename D, int bidx> struct XYZ2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                XYZ2RGBConvert<bidx>(src, &dst.x);
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_XYZ2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::XYZ2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::XYZ2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx>(); \
+        } \
+    };
+
+////////////////////////////////////// RGB <-> HSV ///////////////////////////////////////
+
+    namespace detail
+    {
+        __constant__ int c_HsvDivTable   [256] = {0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211, 130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632, 65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412, 43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693, 32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782, 26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223, 21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991, 18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579, 16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711, 14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221, 13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006, 11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995, 10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141, 10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410, 9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777, 8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224, 8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737, 7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304, 7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917, 6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569, 6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254, 6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968, 5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708, 5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468, 5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249, 5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046, 5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858, 4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684, 4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522, 4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370, 4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229, 4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096};
+        __constant__ int c_HsvDivTable180[256] = {0, 122880, 61440, 40960, 30720, 24576, 20480, 17554, 15360, 13653, 12288, 11171, 10240, 9452, 8777, 8192, 7680, 7228, 6827, 6467, 6144, 5851, 5585, 5343, 5120, 4915, 4726, 4551, 4389, 4237, 4096, 3964, 3840, 3724, 3614, 3511, 3413, 3321, 3234, 3151, 3072, 2997, 2926, 2858, 2793, 2731, 2671, 2614, 2560, 2508, 2458, 2409, 2363, 2318, 2276, 2234, 2194, 2156, 2119, 2083, 2048, 2014, 1982, 1950, 1920, 1890, 1862, 1834, 1807, 1781, 1755, 1731, 1707, 1683, 1661, 1638, 1617, 1596, 1575, 1555, 1536, 1517, 1499, 1480, 1463, 1446, 1429, 1412, 1396, 1381, 1365, 1350, 1336, 1321, 1307, 1293, 1280, 1267, 1254, 1241, 1229, 1217, 1205, 1193, 1182, 1170, 1159, 1148, 1138, 1127, 1117, 1107, 1097, 1087, 1078, 1069, 1059, 1050, 1041, 1033, 1024, 1016, 1007, 999, 991, 983, 975, 968, 960, 953, 945, 938, 931, 924, 917, 910, 904, 897, 890, 884, 878, 871, 865, 859, 853, 847, 842, 836, 830, 825, 819, 814, 808, 803, 798, 793, 788, 783, 778, 773, 768, 763, 759, 754, 749, 745, 740, 736, 731, 727, 723, 719, 714, 710, 706, 702, 698, 694, 690, 686, 683, 679, 675, 671, 668, 664, 661, 657, 654, 650, 647, 643, 640, 637, 633, 630, 627, 624, 621, 617, 614, 611, 608, 605, 602, 599, 597, 594, 591, 588, 585, 582, 580, 577, 574, 572, 569, 566, 564, 561, 559, 556, 554, 551, 549, 546, 544, 541, 539, 537, 534, 532, 530, 527, 525, 523, 521, 518, 516, 514, 512, 510, 508, 506, 504, 502, 500, 497, 495, 493, 492, 490, 488, 486, 484, 482};
+        __constant__ int c_HsvDivTable256[256] = {0, 174763, 87381, 58254, 43691, 34953, 29127, 24966, 21845, 19418, 17476, 15888, 14564, 13443, 12483, 11651, 10923, 10280, 9709, 9198, 8738, 8322, 7944, 7598, 7282, 6991, 6722, 6473, 6242, 6026, 5825, 5638, 5461, 5296, 5140, 4993, 4855, 4723, 4599, 4481, 4369, 4263, 4161, 4064, 3972, 3884, 3799, 3718, 3641, 3567, 3495, 3427, 3361, 3297, 3236, 3178, 3121, 3066, 3013, 2962, 2913, 2865, 2819, 2774, 2731, 2689, 2648, 2608, 2570, 2533, 2497, 2461, 2427, 2394, 2362, 2330, 2300, 2270, 2241, 2212, 2185, 2158, 2131, 2106, 2081, 2056, 2032, 2009, 1986, 1964, 1942, 1920, 1900, 1879, 1859, 1840, 1820, 1802, 1783, 1765, 1748, 1730, 1713, 1697, 1680, 1664, 1649, 1633, 1618, 1603, 1589, 1574, 1560, 1547, 1533, 1520, 1507, 1494, 1481, 1469, 1456, 1444, 1432, 1421, 1409, 1398, 1387, 1376, 1365, 1355, 1344, 1334, 1324, 1314, 1304, 1295, 1285, 1276, 1266, 1257, 1248, 1239, 1231, 1222, 1214, 1205, 1197, 1189, 1181, 1173, 1165, 1157, 1150, 1142, 1135, 1128, 1120, 1113, 1106, 1099, 1092, 1085, 1079, 1072, 1066, 1059, 1053, 1046, 1040, 1034, 1028, 1022, 1016, 1010, 1004, 999, 993, 987, 982, 976, 971, 966, 960, 955, 950, 945, 940, 935, 930, 925, 920, 915, 910, 906, 901, 896, 892, 887, 883, 878, 874, 869, 865, 861, 857, 853, 848, 844, 840, 836, 832, 828, 824, 820, 817, 813, 809, 805, 802, 798, 794, 791, 787, 784, 780, 777, 773, 770, 767, 763, 760, 757, 753, 750, 747, 744, 741, 737, 734, 731, 728, 725, 722, 719, 716, 713, 710, 708, 705, 702, 699, 696, 694, 691, 688, 685};
+        
+        template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const uchar* src, D& dst)
+        {
+            const int hsv_shift = 12;
+            const int* hdiv_table = hr == 180 ? c_HsvDivTable180 : c_HsvDivTable256;
+
+            int b = src[bidx], g = src[1], r = src[bidx^2];
+            int h, s, v = b;
+            int vmin = b, diff;
+            int vr, vg;
+
+            v = ::max(v, g);
+            v = ::max(v, r);
+            vmin = ::min(vmin, g);
+            vmin = ::min(vmin, r);
+
+            diff = v - vmin;
+            vr = v == r ? -1 : 0;
+            vg = v == g ? -1 : 0;
+
+            s = (diff * c_HsvDivTable[v] + (1 << (hsv_shift-1))) >> hsv_shift;
+            h = (vr & (g - b)) + (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
+            h = (h * hdiv_table[diff] + (1 << (hsv_shift-1))) >> hsv_shift;
+            h += h < 0 ? hr : 0;
+
+            dst.x = saturate_cast<uchar>(h);
+            dst.y = (uchar)s;
+            dst.z = (uchar)v;
+        }
+        template <int bidx, int hr, typename D> static __device__ void RGB2HSVConvert(const float* src, D& dst)
+        {
+            const float hscale = hr * (1.f / 360.f);
+
+            float b = src[bidx], g = src[1], r = src[bidx^2];
+            float h, s, v;
+
+            float vmin, diff;
+
+            v = vmin = r;
+            v = fmax(v, g);
+            v = fmax(v, b);
+            vmin = fmin(vmin, g);
+            vmin = fmin(vmin, b);
+
+            diff = v - vmin;
+            s = diff / (float)(::fabs(v) + numeric_limits<float>::epsilon());
+            diff = (float)(60. / (diff + numeric_limits<float>::epsilon()));
+
+            if (v == r)
+                h = (g - b) * diff;
+            else if (v == g)
+                h = (b - r) * diff + 120.f;
+            else
+                h = (r - g) * diff + 240.f;
+
+            if (h < 0) h += 360.f;
+
+            dst.x = h * hscale;
+            dst.y = s;
+            dst.z = v;
+        }
+
+        template <typename T, typename D, int bidx, int hr> struct RGB2HSV : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                RGB2HSVConvert<bidx, hr>(&src.x, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2HSV_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2HSV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HSV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180>(); \
+        } \
+    }; \
+    template <typename T> struct name ## _full_traits \
+    { \
+        typedef detail::RGB2HSV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 256> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HSV<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 256>(); \
+        } \
+    }; \
+    template <> struct name ## _traits<float> \
+    { \
+        typedef detail::RGB2HSV<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HSV<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    }; \
+    template <> struct name ## _full_traits<float> \
+    { \
+        typedef detail::RGB2HSV<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HSV<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        __constant__ int c_HsvSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
+
+        template <int bidx, int HR, typename T> static __device__ void HSV2RGBConvert(const T& src, float* dst)
+        {
+            const float hscale = 6.f / HR;
+            
+            float h = src.x, s = src.y, v = src.z;
+            float b, g, r;
+
+            if( s == 0 )
+                b = g = r = v;
+            else
+            {
+                float tab[4];
+                int sector;
+                h *= hscale;
+                if( h < 0 )
+                    do h += 6; while( h < 0 );
+                else if( h >= 6 )
+                    do h -= 6; while( h >= 6 );
+                sector = __float2int_rd(h);
+                h -= sector;
+
+                tab[0] = v;
+                tab[1] = v*(1.f - s);
+                tab[2] = v*(1.f - s*h);
+                tab[3] = v*(1.f - s*(1.f - h));
+
+                b = tab[c_HsvSectorData[sector][0]];
+                g = tab[c_HsvSectorData[sector][1]];
+                r = tab[c_HsvSectorData[sector][2]];
+            }
+
+            dst[bidx] = b;
+            dst[1] = g;
+            dst[bidx^2] = r;
+        }
+        template <int bidx, int HR, typename T> static __device__ void HSV2RGBConvert(const T& src, uchar* dst)
+        {
+            float3 buf;
+
+            buf.x = src.x;
+            buf.y = src.y * (1.f/255.f);
+            buf.z = src.z * (1.f/255.f);
+
+            HSV2RGBConvert<bidx, HR>(buf, &buf.x);
+
+            dst[0] = saturate_cast<uchar>(buf.x * 255.f);
+            dst[1] = saturate_cast<uchar>(buf.y * 255.f);
+            dst[2] = saturate_cast<uchar>(buf.z * 255.f);
+        }
+
+        template <typename T, typename D, int bidx, int HR> struct HSV2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                HSV2RGBConvert<bidx, HR>(src, &dst.x);
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_HSV2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::HSV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HSV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180>(); \
+        } \
+    }; \
+    template <typename T> struct name ## _full_traits \
+    { \
+        typedef detail::HSV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 255> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HSV2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 255>(); \
+        } \
+    }; \
+    template <> struct name ## _traits<float> \
+    { \
+        typedef detail::HSV2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HSV2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    }; \
+    template <> struct name ## _full_traits<float> \
+    { \
+        typedef detail::HSV2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HSV2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    };
+
+/////////////////////////////////////// RGB <-> HLS ////////////////////////////////////////
+
+    namespace detail
+    {
+        template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const float* src, D& dst)
+        {
+            const float hscale = hr * (1.f / 360.f);
+
+            float b = src[bidx], g = src[1], r = src[bidx^2];
+            float h = 0.f, s = 0.f, l;
+            float vmin, vmax, diff;
+
+            vmax = vmin = r;
+            vmax = fmax(vmax, g);
+            vmax = fmax(vmax, b);
+            vmin = fmin(vmin, g);
+            vmin = fmin(vmin, b);
+
+            diff = vmax - vmin;
+            l = (vmax + vmin) * 0.5f;
+
+            if (diff > numeric_limits<float>::epsilon())
+            {
+                s = l < 0.5f ? diff / (vmax + vmin) : diff / (2.0f - vmax - vmin);
+                diff = 60.f / diff;
+
+                if (vmax == r)
+                    h = (g - b)*diff;
+                else if (vmax == g)
+                    h = (b - r)*diff + 120.f;
+                else
+                    h = (r - g)*diff + 240.f;
+
+                if (h < 0.f) h += 360.f;
+            }
+
+            dst.x = h * hscale;
+            dst.y = l;
+            dst.z = s;
+        }
+        template <int bidx, int hr, typename D> static __device__ void RGB2HLSConvert(const uchar* src, D& dst)
+        {
+            float3 buf;
+
+            buf.x = src[0]*(1.f/255.f);
+            buf.y = src[1]*(1.f/255.f);
+            buf.z = src[2]*(1.f/255.f);
+
+            RGB2HLSConvert<bidx, hr>(&buf.x, buf);
+
+            dst.x = saturate_cast<uchar>(buf.x);
+            dst.y = saturate_cast<uchar>(buf.y*255.f);
+            dst.z = saturate_cast<uchar>(buf.z*255.f);
+        }
+
+        template <typename T, typename D, int bidx, int hr> struct RGB2HLS : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                RGB2HLSConvert<bidx, hr>(&src.x, dst);
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_RGB2HLS_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::RGB2HLS<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HLS<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180>(); \
+        } \
+    }; \
+    template <typename T> struct name ## _full_traits \
+    { \
+        typedef detail::RGB2HLS<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 256> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HLS<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 256>(); \
+        } \
+    }; \
+    template <> struct name ## _traits<float> \
+    { \
+        typedef detail::RGB2HLS<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HLS<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    }; \
+    template <> struct name ## _full_traits<float> \
+    { \
+        typedef detail::RGB2HLS<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::RGB2HLS<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    };
+
+    namespace detail
+    {
+        __constant__ int c_HlsSectorData[6][3] = { {1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0} };
+
+        template <int bidx, int HR, typename T> static __device__ void HLS2RGBConvert(const T& src, float* dst)
+        {
+            const float hscale = 6.0f / HR;
+
+            float h = src.x, l = src.y, s = src.z;
+            float b, g, r;
+
+            if (s == 0)
+                b = g = r = l;
+            else
+            {
+                float tab[4];
+                int sector;
+
+                float p2 = l <= 0.5f ? l * (1 + s) : l + s - l * s;
+                float p1 = 2 * l - p2;
+
+                h *= hscale;
+
+                if( h < 0 )
+                    do h += 6; while( h < 0 );
+                else if( h >= 6 )
+                    do h -= 6; while( h >= 6 );
+
+                sector = __float2int_rd(h);
+                h -= sector;
+
+                tab[0] = p2;
+                tab[1] = p1;
+                tab[2] = p1 + (p2 - p1) * (1 - h);
+                tab[3] = p1 + (p2 - p1) * h;
+
+                b = tab[c_HlsSectorData[sector][0]];
+                g = tab[c_HlsSectorData[sector][1]];
+                r = tab[c_HlsSectorData[sector][2]];
+            }
+
+            dst[bidx] = b;
+            dst[1] = g;
+            dst[bidx^2] = r;
+        }
+        template <int bidx, int HR, typename T> static __device__ void HLS2RGBConvert(const T& src, uchar* dst)
+        {
+            float3 buf;
+
+            buf.x = src.x;
+            buf.y = src.y*(1.f/255.f);
+            buf.z = src.z*(1.f/255.f);
+
+            HLS2RGBConvert<bidx, HR>(buf, &buf.x);
+
+            dst[0] = saturate_cast<uchar>(buf.x*255.f);
+            dst[1] = saturate_cast<uchar>(buf.y*255.f);
+            dst[2] = saturate_cast<uchar>(buf.z*255.f);
+        }
+
+        template <typename T, typename D, int bidx, int HR> struct HLS2RGB : public unary_function<T, D>
+        {
+            __device__ __forceinline__ D operator()(const T& src) const
+            {
+                D dst;
+                HLS2RGBConvert<bidx, HR>(src, &dst.x);
+                setAlpha(dst, ColorChannel<typename VecTraits<T>::elem_type>::max());
+                return dst;
+            }
+        };
+    }
+
+#define OPENCV_GPU_IMPLEMENT_HLS2RGB_TRAITS(name, scn, dcn, bidx) \
+    template <typename T> struct name ## _traits \
+    { \
+        typedef detail::HLS2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HLS2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 180>(); \
+        } \
+    }; \
+    template <typename T> struct name ## _full_traits \
+    { \
+        typedef detail::HLS2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 255> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HLS2RGB<typename TypeVec<T, scn>::vec_type, typename TypeVec<T, dcn>::vec_type, bidx, 255>(); \
+        } \
+    }; \
+    template <> struct name ## _traits<float> \
+    { \
+        typedef detail::HLS2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HLS2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    }; \
+    template <> struct name ## _full_traits<float> \
+    { \
+        typedef detail::HLS2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360> functor_type; \
+        static __host__ __device__ __forceinline__ functor_type create_functor() \
+        { \
+            return detail::HLS2RGB<typename TypeVec<float, scn>::vec_type, typename TypeVec<float, dcn>::vec_type, bidx, 360>(); \
+        } \
+    };
+}}}
+
+#endif // __OPENCV_GPU_COLOR_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/detail/transform.hpp b/modules/gpu/src/opencv2/gpu/device/detail/transform.hpp
new file mode 100644
index 0000000000..22eb7ffada
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/detail/transform.hpp
@@ -0,0 +1,427 @@
+/*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_GPU_TRANSFORM_DETAIL_HPP__
+#define __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
+
+#include "internal_shared.hpp"
+#include "../vec_traits.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    namespace detail
+    {
+        //! Mask accessor
+
+        struct MaskReader
+        {
+            explicit MaskReader(const PtrStep& mask_): mask(mask_) {}
+
+            __device__ __forceinline__ bool operator()(int y, int x) const { return mask.ptr(y)[x]; }
+
+            const PtrStep mask;
+        };
+
+        struct NoMask 
+        {
+            __device__ __forceinline__ bool operator()(int y, int x) const { return true; } 
+        };
+
+        //! Read Write Traits
+
+        template <size_t src_elem_size, size_t dst_elem_size>
+        struct UnReadWriteTraits_
+        {
+            enum { shift = 1 };
+        };
+        template <size_t src_elem_size>
+        struct UnReadWriteTraits_<src_elem_size, 1>
+        {
+            enum { shift = 4 };
+        };
+        template <size_t src_elem_size>
+        struct UnReadWriteTraits_<src_elem_size, 2>
+        {
+            enum { shift = 2 };
+        };
+        template <typename T, typename D> struct UnReadWriteTraits
+        {
+            enum { shift = UnReadWriteTraits_<sizeof(T), sizeof(D)>::shift };
+            
+            typedef typename TypeVec<T, shift>::vec_type read_type;
+            typedef typename TypeVec<D, shift>::vec_type write_type;
+        };
+
+        template <size_t src_elem_size1, size_t src_elem_size2, size_t dst_elem_size>
+        struct BinReadWriteTraits_
+        {
+            enum { shift = 1 };
+        };
+        template <size_t src_elem_size1, size_t src_elem_size2>
+        struct BinReadWriteTraits_<src_elem_size1, src_elem_size2, 1>
+        {
+            enum { shift = 4 };
+        };
+        template <size_t src_elem_size1, size_t src_elem_size2>
+        struct BinReadWriteTraits_<src_elem_size1, src_elem_size2, 2>
+        {
+            enum { shift = 2 };
+        };
+        template <typename T1, typename T2, typename D> struct BinReadWriteTraits
+        {
+            enum {shift = BinReadWriteTraits_<sizeof(T1), sizeof(T2), sizeof(D)>::shift};
+
+            typedef typename TypeVec<T1, shift>::vec_type read_type1;
+            typedef typename TypeVec<T2, shift>::vec_type read_type2;
+            typedef typename TypeVec<D , shift>::vec_type write_type;
+        };
+
+        //! Transform kernels
+
+        template <int shift> struct OpUnroller;
+        template <> struct OpUnroller<1>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src.x);
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src1.x, src2.x);
+            }
+        };
+        template <> struct OpUnroller<2>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src.y);
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src1.x, src2.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src1.y, src2.y);
+            }
+        };
+        template <> struct OpUnroller<3>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src.y);
+                if (mask(y, x_shifted + 2))
+                    dst.z = op(src.z);
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src1.x, src2.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src1.y, src2.y);
+                if (mask(y, x_shifted + 2))
+                    dst.z = op(src1.z, src2.z);
+            }
+        };
+        template <> struct OpUnroller<4>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, const UnOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src.y);
+                if (mask(y, x_shifted + 2))
+                    dst.z = op(src.z);
+                if (mask(y, x_shifted + 3))
+                    dst.w = op(src.w);
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, const BinOp& op, int x_shifted, int y)
+            {
+                if (mask(y, x_shifted))
+                    dst.x = op(src1.x, src2.x);
+                if (mask(y, x_shifted + 1))
+                    dst.y = op(src1.y, src2.y);
+                if (mask(y, x_shifted + 2))
+                    dst.z = op(src1.z, src2.z);
+                if (mask(y, x_shifted + 3))
+                    dst.w = op(src1.w, src2.w);
+            }
+        };
+
+        template <typename T, typename D, typename UnOp, typename Mask>
+        __global__ static void transformSmart(const DevMem2D_<T> src_, PtrStep_<D> dst_, const Mask mask, const UnOp op)
+        {
+            typedef typename UnReadWriteTraits<T, D>::read_type read_type;
+            typedef typename UnReadWriteTraits<T, D>::write_type write_type;
+            const int shift = UnReadWriteTraits<T, D>::shift;
+
+            const int x = threadIdx.x + blockIdx.x * blockDim.x;
+            const int y = threadIdx.y + blockIdx.y * blockDim.y;
+            const int x_shifted = x * shift;
+
+            if (y < src_.rows)
+            {
+                const T* src = src_.ptr(y);
+                D* dst = dst_.ptr(y);
+
+                if (x_shifted + shift - 1 < src_.cols)
+                {
+                    const read_type src_n_el = ((const read_type*)src)[x];
+                    write_type dst_n_el;
+
+                    OpUnroller<shift>::unroll(src_n_el, dst_n_el, mask, op, x_shifted, y);
+
+                    ((write_type*)dst)[x] = dst_n_el;
+                }
+                else
+                {
+                    for (int real_x = x_shifted; real_x < src_.cols; ++real_x)
+                    {
+                        if (mask(y, real_x))
+                            dst[real_x] = op(src[real_x]);
+                    }
+                }
+            }
+        }
+
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static __global__ void transformSimple(const DevMem2D_<T> src, PtrStep_<D> dst, const Mask mask, const UnOp op)
+        {
+		    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+		    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+            if (x < src.cols && y < src.rows && mask(y, x))
+            {
+                dst.ptr(y)[x] = op(src.ptr(y)[x]);
+            }
+        }
+
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        __global__ static void transformSmart(const DevMem2D_<T1> src1_, const PtrStep_<T2> src2_, PtrStep_<D> dst_, 
+            const Mask mask, const BinOp op)
+        {
+            typedef typename BinReadWriteTraits<T1, T2, D>::read_type1 read_type1;
+            typedef typename BinReadWriteTraits<T1, T2, D>::read_type2 read_type2;
+            typedef typename BinReadWriteTraits<T1, T2, D>::write_type write_type;
+            const int shift = BinReadWriteTraits<T1, T2, D>::shift;
+
+            const int x = threadIdx.x + blockIdx.x * blockDim.x;
+            const int y = threadIdx.y + blockIdx.y * blockDim.y;
+            const int x_shifted = x * shift;
+
+            if (y < src1_.rows)
+            {
+                const T1* src1 = src1_.ptr(y);
+                const T2* src2 = src2_.ptr(y);
+                D* dst = dst_.ptr(y);
+
+                if (x_shifted + shift - 1 < src1_.cols)
+                {
+                    const read_type1 src1_n_el = ((const read_type1*)src1)[x];
+                    const read_type2 src2_n_el = ((const read_type2*)src2)[x];
+                    write_type dst_n_el;
+                    
+                    OpUnroller<shift>::unroll(src1_n_el, src2_n_el, dst_n_el, mask, op, x_shifted, y);
+
+                    ((write_type*)dst)[x] = dst_n_el;
+                }
+                else
+                {
+                    for (int real_x = x_shifted; real_x < src1_.cols; ++real_x)
+                    {
+                        if (mask(y, real_x))
+                            dst[real_x] = op(src1[real_x], src2[real_x]);
+                    }
+                }
+            }
+        }
+
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static __global__ void transformSimple(const DevMem2D_<T1> src1, const PtrStep_<T2> src2, PtrStep_<D> dst, 
+            const Mask mask, const BinOp op)
+        {
+		    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+		    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+            if (x < src1.cols && y < src1.rows && mask(y, x))
+            {
+                const T1 src1_data = src1.ptr(y)[x];
+                const T2 src2_data = src2.ptr(y)[x];
+                dst.ptr(y)[x] = op(src1_data, src2_data);
+            }
+        }        
+
+        template <bool UseSmart> struct TransformDispatcher;
+        template<> struct TransformDispatcher<false>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+            {
+                dim3 threads(16, 16, 1);
+                dim3 grid(1, 1, 1);
+
+                grid.x = divUp(src.cols, threads.x);
+                grid.y = divUp(src.rows, threads.y);        
+
+                transformSimple<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
+                cudaSafeCall( cudaGetLastError() );
+
+                if (stream == 0)
+                    cudaSafeCall( cudaDeviceSynchronize() ); 
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+            {
+                dim3 threads(16, 16, 1);
+                dim3 grid(1, 1, 1);
+
+                grid.x = divUp(src1.cols, threads.x);
+                grid.y = divUp(src1.rows, threads.y);        
+
+                transformSimple<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
+                cudaSafeCall( cudaGetLastError() );
+
+                if (stream == 0)
+                    cudaSafeCall( cudaDeviceSynchronize() );            
+            }
+        };
+        template<> struct TransformDispatcher<true>
+        {
+            template <typename T, typename D, typename UnOp, typename Mask>
+            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+            {
+                const int shift = UnReadWriteTraits<T, D>::shift;
+
+                dim3 threads(16, 16, 1);
+                dim3 grid(1, 1, 1);            
+
+                grid.x = divUp(src.cols, threads.x * shift);
+                grid.y = divUp(src.rows, threads.y);        
+
+                transformSmart<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
+                cudaSafeCall( cudaGetLastError() );
+
+                if (stream == 0)
+                    cudaSafeCall( cudaDeviceSynchronize() );
+            }
+
+            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+            {
+                const int shift = BinReadWriteTraits<T1, T2, D>::shift;
+
+                dim3 threads(16, 16, 1);
+                dim3 grid(1, 1, 1);
+
+                grid.x = divUp(src1.cols, threads.x * shift);
+                grid.y = divUp(src1.rows, threads.y);        
+
+                transformSmart<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
+                cudaSafeCall( cudaGetLastError() );
+
+                if (stream == 0)
+                    cudaSafeCall( cudaDeviceSynchronize() );            
+            }
+        };
+
+        template <typename T, typename D, int scn, int dcn> struct UseSmartUn_
+        {
+            static const bool value = false;
+        };
+        template <typename T, typename D> struct UseSmartUn_<T, D, 1, 1>
+        {
+            static const bool value = UnReadWriteTraits<T, D>::shift != 1;
+        };
+        template <typename T, typename D> struct UseSmartUn
+        {
+            static const bool value = UseSmartUn_<T, D, VecTraits<T>::cn, VecTraits<D>::cn>::value;
+        };
+
+        template <typename T1, typename T2, typename D, int src1cn, int src2cn, int dstcn> struct UseSmartBin_
+        {
+            static const bool value = false;
+        };
+        template <typename T1, typename T2, typename D> struct UseSmartBin_<T1, T2, D, 1, 1, 1>
+        {
+            static const bool value = BinReadWriteTraits<T1, T2, D>::shift != 1;
+        };
+        template <typename T1, typename T2, typename D> struct UseSmartBin
+        {
+            static const bool value = UseSmartBin_<T1, T2, D, VecTraits<T1>::cn, VecTraits<T2>::cn, VecTraits<D>::cn>::value;
+        };
+
+        template <typename T, typename D, typename UnOp, typename Mask>
+        static void transform_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, const Mask& mask, cudaStream_t stream)
+        {
+            TransformDispatcher< UseSmartUn<T, D>::value >::call(src, dst, op, mask, stream);
+        }
+
+        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
+        static void transform_caller(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, const BinOp& op, const Mask& mask, cudaStream_t stream)
+        {
+            TransformDispatcher< UseSmartBin<T1, T2, D>::value >::call(src1, src2, dst, op, mask, stream);
+        }
+    }
+}}}
+
+#endif // __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/functional.hpp b/modules/gpu/src/opencv2/gpu/device/functional.hpp
new file mode 100644
index 0000000000..b3abdf64a1
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/functional.hpp
@@ -0,0 +1,336 @@
+/*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_GPU_FUNCTIONAL_HPP__
+#define __OPENCV_GPU_FUNCTIONAL_HPP__
+
+#include <thrust/functional.h>
+#include "internal_shared.hpp"
+#include "saturate_cast.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    using thrust::unary_function;
+    using thrust::binary_function;
+
+    using thrust::plus;
+    using thrust::minus;
+    using thrust::multiplies;
+    using thrust::divides;
+    using thrust::modulus;
+    using thrust::negate;
+    
+    using thrust::equal_to;
+    using thrust::not_equal_to;
+    using thrust::greater;
+    using thrust::less;
+    using thrust::greater_equal;
+    using thrust::less_equal;
+    
+    using thrust::logical_and;
+    using thrust::logical_or;
+    using thrust::logical_not;
+
+    using thrust::bit_and;
+    using thrust::bit_or;
+    using thrust::bit_xor;
+    template <typename T> struct bit_not : unary_function<T, T>
+    {
+        __forceinline__ __device__ T operator ()(const T& v) const {return ~v;}
+    };
+
+    using thrust::identity;
+
+#define OPENCV_GPU_IMPLEMENT_MINMAX(name, type, op) \
+    template <> struct name<type> : binary_function<type, type, type> \
+    { \
+        __forceinline__ __device__ type operator()(type lhs, type rhs) const {return op(lhs, rhs);} \
+    };
+
+    template <typename T> struct maximum : binary_function<T, T, T>
+    {
+        __forceinline__ __device__ T operator()(const T& lhs, const T& rhs) const {return lhs < rhs ? rhs : lhs;}
+    };
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uchar, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, schar, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, char, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, ushort, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, short, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, int, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uint, max)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, float, fmax)
+    OPENCV_GPU_IMPLEMENT_MINMAX(maximum, double, fmax)
+
+    template <typename T> struct minimum : binary_function<T, T, T>
+    {
+        __forceinline__ __device__ T operator()(const T &lhs, const T &rhs) const {return lhs < rhs ? lhs : rhs;}
+    };
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uchar, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, schar, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, char, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, ushort, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, short, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, int, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uint, min)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, float, fmin)
+    OPENCV_GPU_IMPLEMENT_MINMAX(minimum, double, fmin)
+
+#undef OPENCV_GPU_IMPLEMENT_MINMAX
+    
+    using thrust::project1st;
+    using thrust::project2nd;
+
+    using thrust::unary_negate;
+    using thrust::not1;
+
+    using thrust::binary_negate;
+    using thrust::not2;
+
+#define OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(func) \
+    template <typename T> struct func ## _func : unary_function<T, float> \
+    { \
+        __forceinline__ __device__ float operator ()(const T& v) const \
+        { \
+            return func ## f(v); \
+        } \
+    }; \
+    template <> struct func ## _func<double> : unary_function<double, double> \
+    { \
+        __forceinline__ __device__ double operator ()(double v) const \
+        { \
+            return func(v); \
+        } \
+    };
+#define OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(func) \
+    template <typename T> struct func ## _func : binary_function<T, T, float> \
+    { \
+        __forceinline__ __device__ float operator ()(const T& v1, const T& v2) const \
+        { \
+            return func ## f(v1, v2); \
+        } \
+    }; \
+    template <> struct func ## _func<double> : binary_function<double, double, double> \
+    { \
+        __forceinline__ __device__ double operator ()(double v1, double v2) const \
+        { \
+            return func(v1, v2); \
+        } \
+    };
+
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(fabs)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sqrt)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp2)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp10)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log2)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(log10)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sin)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cos)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tan)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asin)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acos)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atan)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sinh)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(cosh)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(tanh)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(asinh)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(acosh)
+    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(atanh)
+
+    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(hypot)
+    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(atan2)
+    OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(pow)
+
+#undef OPENCV_GPU_IMPLEMENT_UN_FUNCTOR
+#undef OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR
+
+    template<typename T> struct hypot_sqr_func : binary_function<T, T, float> 
+    {
+        __forceinline__ __device__ T operator ()(T src1, T src2) const
+        {
+            return src1 * src1 + src2 * src2;
+        }
+    };
+
+    template <typename T, typename D> struct saturate_cast_func : unary_function<T, D>
+    {
+        __forceinline__ __device__ D operator ()(const T& v) const
+        {
+            return saturate_cast<D>(v);
+        }
+    };
+
+    template <typename T> struct thresh_binary_func : unary_function<T, T>
+    {
+        __forceinline__ __host__ __device__ thresh_binary_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
+
+        __forceinline__ __device__ T operator()(const T& src) const
+        {
+            return src > thresh ? maxVal : 0;
+        }
+
+        const T thresh;
+        const T maxVal;
+    };
+    template <typename T> struct thresh_binary_inv_func : unary_function<T, T>
+    {
+        __forceinline__ __host__ __device__ thresh_binary_inv_func(T thresh_, T maxVal_) : thresh(thresh_), maxVal(maxVal_) {}
+
+        __forceinline__ __device__ T operator()(const T& src) const
+        {
+            return src > thresh ? 0 : maxVal;
+        }
+
+        const T thresh;
+        const T maxVal;
+    };
+    template <typename T> struct thresh_trunc_func : unary_function<T, T>
+    {
+        explicit __forceinline__ __host__ __device__ thresh_trunc_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+
+        __forceinline__ __device__ T operator()(const T& src) const
+        {
+            return minimum<T>()(src, thresh);
+        }
+
+        const T thresh;
+    };
+    template <typename T> struct thresh_to_zero_func : unary_function<T, T>
+    {
+        explicit __forceinline__ __host__ __device__ thresh_to_zero_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+
+        __forceinline__ __device__ T operator()(const T& src) const
+        {
+            return src > thresh ? src : 0;
+        }
+
+        const T thresh;
+    };
+    template <typename T> struct thresh_to_zero_inv_func : unary_function<T, T>
+    {
+        explicit __forceinline__ __host__ __device__ thresh_to_zero_inv_func(T thresh_, T maxVal_ = 0) : thresh(thresh_) {}
+
+        __forceinline__ __device__ T operator()(const T& src) const
+        {
+            return src > thresh ? 0 : src;
+        }
+
+        const T thresh;
+    };
+
+    template <typename Op> struct binder1st : unary_function<typename Op::second_argument_type, typename Op::result_type> 
+    {
+        __forceinline__ __host__ __device__ binder1st(const Op& op_, const typename Op::first_argument_type& arg1_) : op(op_), arg1(arg1_) {}
+
+        __forceinline__ __device__ typename Op::result_type operator ()(const typename Op::second_argument_type& a) const
+        {
+            return op(arg1, a);
+        }
+
+        const Op op;
+        const typename Op::first_argument_type arg1;
+    };
+    template <typename Op, typename T> static __forceinline__ __host__ __device__ binder1st<Op> bind1st(const Op& op, const T& x)
+    {
+        return binder1st<Op>(op, typename Op::first_argument_type(x));
+    }
+    template <typename Op> struct binder2nd : unary_function<typename Op::first_argument_type, typename Op::result_type> 
+    {
+        __forceinline__ __host__ __device__ binder2nd(const Op& op_, const typename Op::second_argument_type& arg2_) : op(op_), arg2(arg2_) {}
+
+        __forceinline__ __device__ typename Op::result_type operator ()(const typename Op::first_argument_type& a) const
+        {
+            return op(a, arg2);
+        }
+
+        const Op op;
+        const typename Op::second_argument_type arg2;
+    };
+    template <typename Op, typename T> static __forceinline__ __host__ __device__ binder2nd<Op> bind2nd(const Op& op, const T& x)
+    {
+        return binder2nd<Op>(op, typename Op::second_argument_type(x));
+    }
+
+    template <typename T1, typename T2> struct BinOpTraits
+    {
+        typedef int argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, T>
+    {
+        typedef T argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, double>
+    {
+        typedef double argument_type;
+    };
+    template <typename T> struct BinOpTraits<double, T>
+    {
+        typedef double argument_type;
+    };
+    template <> struct BinOpTraits<double, double>
+    {
+        typedef double argument_type;
+    };
+    template <typename T> struct BinOpTraits<T, float>
+    {
+        typedef float argument_type;
+    };
+    template <typename T> struct BinOpTraits<float, T>
+    {
+        typedef float argument_type;
+    };
+    template <> struct BinOpTraits<float, float>
+    {
+        typedef float argument_type;
+    };
+    template <> struct BinOpTraits<double, float>
+    {
+        typedef double argument_type;
+    };
+    template <> struct BinOpTraits<float, double>
+    {
+        typedef double argument_type;
+    };
+}}}
+
+#endif // __OPENCV_GPU_FUNCTIONAL_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/kernels.hpp b/modules/gpu/src/opencv2/gpu/device/kernels.hpp
new file mode 100644
index 0000000000..5f3f04161f
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/kernels.hpp
@@ -0,0 +1,123 @@
+/*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_GPU_KENELRS_HPP__
+#define __OPENCV_GPU_KENELRS_HPP__
+
+namespace cv
+{
+	namespace gpu
+	{
+		namespace device
+		{
+			struct Grid1D
+			{
+				static __forceinline__ __device__ int STRIDE() { return  gridDim.x * blockDim.x; }
+				static __forceinline__ __device__ int SHIFT()  { return blockIdx.x * blockDim.x + threadIdx.x; }
+			};
+
+			struct Block1D
+			{
+				static __forceinline__ __device__ int STRIDE() { return blockDim.x; }
+				static __forceinline__ __device__ int SHIFT()  { return threadIdx.x; }			
+			};
+
+			struct Warp
+			{
+				static __forceinline__ __device__ int STRIDE() { return warpSize };            
+				static __forceinline__ __device__ int SHIFT()  { return threadIdx.x & (warpSize - 1); }			
+			};
+
+			template <class Worker, typename T>
+			__forceinline__ __device__ void Copy(const T* in, T *out, int length)
+			{
+				int STRIDE = Worker::STRIDE();
+				int idx    = Worker::SHIFT();				
+				
+				for (; idx < length; idx += STRIDE) 
+	                out[idx] = in[idx];
+			}
+
+			template <class Worker, typename InIter, typename OutIter>
+			__forceinline__ __device__ void Copy(InIter beg, InIter end, OutIter out)
+			{
+				int STRIDE = Worker::STRIDE();
+				int SHIFT  = Worker::SHIFT();
+				
+				beg += SHIFT;
+				out += SHIFT;
+
+				for (; beg < end; beg += STRIDE, out += STRIDE) 
+					*out = *beg;				
+			}		
+
+			 template <class Worker, typename T>
+			__forceinline__ __device__ void Yota(T* out, int beg, int end)
+			{	            				
+				int STRIDE = Worker::STRIDE();
+				int SHIFT  = Worker::SHIFT();
+
+				int idx    = SHIFT;
+				int cur    = beg + SHIFT;
+				int length = end - beg;
+				
+				for (; idx < length; idx += STRIDE, cur += STRIDE)
+					out[idx] = cur;				
+			}
+
+			template <class Worker, typename OutIter>
+			__forceinline__ __device__ void Yota(OutIter beg, OutIter end, int val)
+			{
+				int STRIDE = Worker::STRIDE();
+				int SHIFT  = Worker::SHIFT();
+
+				beg += SHIFT;
+				val += SHIFT;
+				
+				for (; beg < end; beg += STRIDE, val += STRIDE)
+					*beg = val;
+			}
+		}
+	}
+}
+
+#endif /* __OPENCV_GPU_KENELRS_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/limits_gpu.hpp b/modules/gpu/src/opencv2/gpu/device/limits.hpp
similarity index 87%
rename from modules/gpu/src/opencv2/gpu/device/limits_gpu.hpp
rename to modules/gpu/src/opencv2/gpu/device/limits.hpp
index 28231dcf80..b0b73f2e35 100644
--- a/modules/gpu/src/opencv2/gpu/device/limits_gpu.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/limits.hpp
@@ -45,7 +45,7 @@
 
 namespace cv { namespace gpu { namespace device
 {
-    template<class T> struct numeric_limits_gpu
+    template<class T> struct numeric_limits
     {
         typedef T type;
         __device__ __forceinline__ static type min()  { return type(); };
@@ -59,7 +59,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed;
     };
 
-    template<> struct numeric_limits_gpu<bool>
+    template<> struct numeric_limits<bool>
     {
         typedef bool type;
         __device__ __forceinline__ static type min() { return false; };
@@ -73,7 +73,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = false;
     };
 
-    template<> struct numeric_limits_gpu<char>
+    template<> struct numeric_limits<char>
     {
         typedef char type;
         __device__ __forceinline__ static type min() { return CHAR_MIN; };
@@ -87,7 +87,21 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = (char)-1 == -1;
     };
 
-    template<> struct numeric_limits_gpu<unsigned char>
+     template<> struct numeric_limits<signed char>
+    {
+        typedef char type;
+        __device__ __forceinline__ static type min() { return CHAR_MIN; };
+        __device__ __forceinline__ static type max() { return CHAR_MAX; };
+        __device__ __forceinline__ static type epsilon();
+        __device__ __forceinline__ static type round_error();
+        __device__ __forceinline__ static type denorm_min();
+        __device__ __forceinline__ static type infinity();
+        __device__ __forceinline__ static type quiet_NaN();
+        __device__ __forceinline__ static type signaling_NaN();
+        static const bool is_signed = (signed char)-1 == -1;
+    };
+
+    template<> struct numeric_limits<unsigned char>
     {
         typedef unsigned char type;
         __device__ __forceinline__ static type min() { return 0; };
@@ -101,7 +115,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = false;
     };
 
-    template<> struct numeric_limits_gpu<short>
+    template<> struct numeric_limits<short>
     {
         typedef short type;
         __device__ __forceinline__ static type min() { return SHRT_MIN; };
@@ -115,7 +129,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = true;
     };
 
-    template<> struct numeric_limits_gpu<unsigned short>
+    template<> struct numeric_limits<unsigned short>
     {
         typedef unsigned short type;
         __device__ __forceinline__ static type min() { return 0; };
@@ -129,7 +143,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = false;
     };
 
-    template<> struct numeric_limits_gpu<int>
+    template<> struct numeric_limits<int>
     {
         typedef int type;
         __device__ __forceinline__ static type min() { return INT_MIN; };
@@ -144,7 +158,7 @@ namespace cv { namespace gpu { namespace device
     };
 
 
-    template<> struct numeric_limits_gpu<unsigned int>
+    template<> struct numeric_limits<unsigned int>
     {
         typedef unsigned int type;
         __device__ __forceinline__ static type min() { return 0; };
@@ -158,7 +172,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = false;
     };
 
-    template<> struct numeric_limits_gpu<long>
+    template<> struct numeric_limits<long>
     {
         typedef long type;
         __device__ __forceinline__ static type min() { return LONG_MIN; };
@@ -172,7 +186,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = true;
     };
 
-    template<> struct numeric_limits_gpu<unsigned long>
+    template<> struct numeric_limits<unsigned long>
     {
         typedef unsigned long type;
         __device__ __forceinline__ static type min() { return 0; };
@@ -186,7 +200,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = false;
     };
 
-    template<> struct numeric_limits_gpu<float>
+    template<> struct numeric_limits<float>
     {
         typedef float type;
         __device__ __forceinline__ static type min() { return 1.175494351e-38f/*FLT_MIN*/; };
@@ -200,7 +214,7 @@ namespace cv { namespace gpu { namespace device
         static const bool is_signed = true;
     };
 
-    template<> struct numeric_limits_gpu<double>
+    template<> struct numeric_limits<double>
     {
         typedef double type;
         __device__ __forceinline__ static type min() { return 2.2250738585072014e-308/*DBL_MIN*/; };
diff --git a/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp b/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
index 3426524241..55c9cb99b8 100644
--- a/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp
@@ -45,128 +45,122 @@
 
 #include "internal_shared.hpp"
 
-namespace cv
+namespace cv { namespace gpu { namespace device
 {
-    namespace gpu
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(ushort v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(short v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(uint v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(int v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(float v) { return _Tp(v); }
+    template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(double v) { return _Tp(v); }
+
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(schar v)
+    { return (uchar)max((int)v, 0); }
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(ushort v)
+    { return (uchar)min((uint)v, (uint)UCHAR_MAX); }
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(int v)
+    { return (uchar)((uint)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(uint v)
+    { return (uchar)min(v, (uint)UCHAR_MAX); }
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(short v)
+    { return saturate_cast<uchar>((uint)v); }
+
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(float v)
+    { int iv = __float2int_rn(v); return saturate_cast<uchar>(iv); }
+    template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(double v)
     {
-        namespace device
-        {
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(ushort v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(short v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(uint v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(int v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(float v) { return _Tp(v); }
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(double v) { return _Tp(v); }
-
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(schar v)
-            { return (uchar)max((int)v, 0); }
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(ushort v)
-            { return (uchar)min((uint)v, (uint)UCHAR_MAX); }
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(int v)
-            { return (uchar)((uint)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(uint v)
-            { return (uchar)min(v, (uint)UCHAR_MAX); }
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(short v)
-            { return saturate_cast<uchar>((uint)v); }
-
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(float v)
-            { int iv = __float2int_rn(v); return saturate_cast<uchar>(iv); }
-            template<> static __device__ __forceinline__ uchar saturate_cast<uchar>(double v)
-            {
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-                int iv = __double2int_rn(v); return saturate_cast<uchar>(iv);
-            #else
-                return saturate_cast<uchar>((float)v);
-            #endif
-            }
-
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(uchar v)
-            { return (schar)min((int)v, SCHAR_MAX); }
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(ushort v)
-            { return (schar)min((uint)v, (uint)SCHAR_MAX); }
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(int v)
-            {
-                return (schar)((uint)(v-SCHAR_MIN) <= (uint)UCHAR_MAX ?
-                            v : v > 0 ? SCHAR_MAX : SCHAR_MIN);
-            }
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(short v)
-            { return saturate_cast<schar>((int)v); }
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(uint v)
-            { return (schar)min(v, (uint)SCHAR_MAX); }
-
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(float v)
-            { int iv = __float2int_rn(v); return saturate_cast<schar>(iv); }
-            template<> static __device__ __forceinline__ schar saturate_cast<schar>(double v)
-            {             
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-                int iv = __double2int_rn(v); return saturate_cast<schar>(iv);
-            #else
-                return saturate_cast<schar>((float)v);
-            #endif
-            }
-
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(schar v)
-            { return (ushort)max((int)v, 0); }
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(short v)
-            { return (ushort)max((int)v, 0); }
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(int v)
-            { return (ushort)((uint)v <= (uint)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(uint v)
-            { return (ushort)min(v, (uint)USHRT_MAX); }
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(float v)
-            { int iv = __float2int_rn(v); return saturate_cast<ushort>(iv); }
-            template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(double v)
-            {             
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-                int iv = __double2int_rn(v); return saturate_cast<ushort>(iv);
-            #else
-                return saturate_cast<ushort>((float)v);
-            #endif
-            }
-
-            template<> static __device__ __forceinline__ short saturate_cast<short>(ushort v)
-            { return (short)min((int)v, SHRT_MAX); }
-            template<> static __device__ __forceinline__ short saturate_cast<short>(int v)
-            {
-                return (short)((uint)(v - SHRT_MIN) <= (uint)USHRT_MAX ?
-                        v : v > 0 ? SHRT_MAX : SHRT_MIN);
-            }
-            template<> static __device__ __forceinline__ short saturate_cast<short>(uint v)
-            { return (short)min(v, (uint)SHRT_MAX); }
-            template<> static __device__ __forceinline__ short saturate_cast<short>(float v)
-            { int iv = __float2int_rn(v); return saturate_cast<short>(iv); }
-            template<> static __device__ __forceinline__ short saturate_cast<short>(double v)
-            {            
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-                int iv = __double2int_rn(v); return saturate_cast<short>(iv);
-            #else
-                return saturate_cast<short>((float)v);
-            #endif
-            }
-
-            template<> static __device__ __forceinline__ int saturate_cast<int>(float v) { return __float2int_rn(v); }
-            template<> static __device__ __forceinline__ int saturate_cast<int>(double v) 
-            {
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130 
-                return __double2int_rn(v);
-            #else
-                return saturate_cast<int>((float)v);
-            #endif
-            }
-
-            template<> static __device__ __forceinline__ uint saturate_cast<uint>(float v){ return __float2uint_rn(v); }
-            template<> static __device__ __forceinline__ uint saturate_cast<uint>(double v) 
-            {            
-            #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
-                return __double2uint_rn(v);
-            #else
-                return saturate_cast<uint>((float)v);
-            #endif
-            }
-        }
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
+        int iv = __double2int_rn(v); return saturate_cast<uchar>(iv);
+    #else
+        return saturate_cast<uchar>((float)v);
+    #endif
     }
-}
+
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(uchar v)
+    { return (schar)min((int)v, SCHAR_MAX); }
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(ushort v)
+    { return (schar)min((uint)v, (uint)SCHAR_MAX); }
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(int v)
+    {
+        return (schar)((uint)(v-SCHAR_MIN) <= (uint)UCHAR_MAX ?
+                    v : v > 0 ? SCHAR_MAX : SCHAR_MIN);
+    }
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(short v)
+    { return saturate_cast<schar>((int)v); }
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(uint v)
+    { return (schar)min(v, (uint)SCHAR_MAX); }
+
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(float v)
+    { int iv = __float2int_rn(v); return saturate_cast<schar>(iv); }
+    template<> static __device__ __forceinline__ schar saturate_cast<schar>(double v)
+    {             
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
+        int iv = __double2int_rn(v); return saturate_cast<schar>(iv);
+    #else
+        return saturate_cast<schar>((float)v);
+    #endif
+    }
+
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(schar v)
+    { return (ushort)max((int)v, 0); }
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(short v)
+    { return (ushort)max((int)v, 0); }
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(int v)
+    { return (ushort)((uint)v <= (uint)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(uint v)
+    { return (ushort)min(v, (uint)USHRT_MAX); }
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(float v)
+    { int iv = __float2int_rn(v); return saturate_cast<ushort>(iv); }
+    template<> static __device__ __forceinline__ ushort saturate_cast<ushort>(double v)
+    {             
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
+        int iv = __double2int_rn(v); return saturate_cast<ushort>(iv);
+    #else
+        return saturate_cast<ushort>((float)v);
+    #endif
+    }
+
+    template<> static __device__ __forceinline__ short saturate_cast<short>(ushort v)
+    { return (short)min((int)v, SHRT_MAX); }
+    template<> static __device__ __forceinline__ short saturate_cast<short>(int v)
+    {
+        return (short)((uint)(v - SHRT_MIN) <= (uint)USHRT_MAX ?
+                v : v > 0 ? SHRT_MAX : SHRT_MIN);
+    }
+    template<> static __device__ __forceinline__ short saturate_cast<short>(uint v)
+    { return (short)min(v, (uint)SHRT_MAX); }
+    template<> static __device__ __forceinline__ short saturate_cast<short>(float v)
+    { int iv = __float2int_rn(v); return saturate_cast<short>(iv); }
+    template<> static __device__ __forceinline__ short saturate_cast<short>(double v)
+    {            
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
+        int iv = __double2int_rn(v); return saturate_cast<short>(iv);
+    #else
+        return saturate_cast<short>((float)v);
+    #endif
+    }
+
+    template<> static __device__ __forceinline__ int saturate_cast<int>(float v) { return __float2int_rn(v); }
+    template<> static __device__ __forceinline__ int saturate_cast<int>(double v) 
+    {
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130 
+        return __double2int_rn(v);
+    #else
+        return saturate_cast<int>((float)v);
+    #endif
+    }
+
+    template<> static __device__ __forceinline__ uint saturate_cast<uint>(float v){ return __float2uint_rn(v); }
+    template<> static __device__ __forceinline__ uint saturate_cast<uint>(double v) 
+    {            
+    #if defined (__CUDA_ARCH__) && __CUDA_ARCH__ >= 130
+        return __double2uint_rn(v);
+    #else
+        return saturate_cast<uint>((float)v);
+    #endif
+    }
+}}}
 
 #endif /* __OPENCV_GPU_SATURATE_CAST_HPP__ */
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/transform.hpp b/modules/gpu/src/opencv2/gpu/device/transform.hpp
index 65d4ad9bc9..4f756e36da 100644
--- a/modules/gpu/src/opencv2/gpu/device/transform.hpp
+++ b/modules/gpu/src/opencv2/gpu/device/transform.hpp
@@ -43,421 +43,34 @@
 #ifndef __OPENCV_GPU_TRANSFORM_HPP__
 #define __OPENCV_GPU_TRANSFORM_HPP__
 
-#include "internal_shared.hpp"
-#include "vecmath.hpp"
+#include "detail/transform.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
-    //! Mask accessor
-
-    class MaskReader
+    template <typename T, typename D, typename UnOp>
+    static void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const UnOp& op, cudaStream_t stream = 0)
     {
-    public:
-        explicit MaskReader(const PtrStep& mask_): mask(mask_) {}
-
-        __device__ __forceinline__ bool operator()(int y, int x) const { return mask.ptr(y)[x]; }
-
-    private:
-        PtrStep mask;
-    };
-
-    struct NoMask 
+        detail::transform_caller(src, dst, op, detail::NoMask(), stream);
+    }
+    template <typename T, typename D, typename UnOp>
+    static void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const PtrStep& mask, const UnOp& op, 
+        cudaStream_t stream = 0)
     {
-        __device__ __forceinline__ bool operator()(int y, int x) const { return true; } 
-    };
-
-    //! Read Write Traits
-
-    template <size_t src_elem_size, size_t dst_elem_size>
-    struct UnReadWriteTraits_
-    {
-        enum { shift = 1 };
-    };
-    template <size_t src_elem_size>
-    struct UnReadWriteTraits_<src_elem_size, 1>
-    {
-        enum { shift = 4 };
-    };
-    template <size_t src_elem_size>
-    struct UnReadWriteTraits_<src_elem_size, 2>
-    {
-        enum { shift = 2 };
-    };
-    template <typename T, typename D> struct UnReadWriteTraits
-    {
-        enum { shift = UnReadWriteTraits_<sizeof(T), sizeof(D)>::shift };
-        
-        typedef typename TypeVec<T, shift>::vec_t read_type;
-        typedef typename TypeVec<D, shift>::vec_t write_type;
-    };
-
-    template <size_t src_elem_size1, size_t src_elem_size2, size_t dst_elem_size>
-    struct BinReadWriteTraits_
-    {
-        enum { shift = 1 };
-    };
-    template <size_t src_elem_size1, size_t src_elem_size2>
-    struct BinReadWriteTraits_<src_elem_size1, src_elem_size2, 1>
-    {
-        enum { shift = 4 };
-    };
-    template <size_t src_elem_size1, size_t src_elem_size2>
-    struct BinReadWriteTraits_<src_elem_size1, src_elem_size2, 2>
-    {
-        enum { shift = 2 };
-    };
-    template <typename T1, typename T2, typename D> struct BinReadWriteTraits
-    {
-        enum {shift = BinReadWriteTraits_<sizeof(T1), sizeof(T2), sizeof(D)>::shift};
-
-        typedef typename TypeVec<T1, shift>::vec_t read_type1;
-        typedef typename TypeVec<T2, shift>::vec_t read_type2;
-        typedef typename TypeVec<D , shift>::vec_t write_type;
-    };
-
-    //! Transform kernels
-
-    template <int shift> struct OpUnroller;
-    template <> struct OpUnroller<1>
-    {
-        template <typename T, typename D, typename UnOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src.x);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src1.x, src2.x);
-        }
-    };
-    template <> struct OpUnroller<2>
-    {
-        template <typename T, typename D, typename UnOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src.y);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src1.x, src2.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src1.y, src2.y);
-        }
-    };
-    template <> struct OpUnroller<3>
-    {
-        template <typename T, typename D, typename UnOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src.y);
-            if (mask(y, x_shifted + 2))
-                dst.z = op(src.z);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src1.x, src2.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src1.y, src2.y);
-            if (mask(y, x_shifted + 2))
-                dst.z = op(src1.z, src2.z);
-        }
-    };
-    template <> struct OpUnroller<4>
-    {
-        template <typename T, typename D, typename UnOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T& src, D& dst, const Mask& mask, UnOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src.y);
-            if (mask(y, x_shifted + 2))
-                dst.z = op(src.z);
-            if (mask(y, x_shifted + 3))
-                dst.w = op(src.w);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static __device__ __forceinline__ void unroll(const T1& src1, const T2& src2, D& dst, const Mask& mask, BinOp& op, int x_shifted, int y)
-        {
-            if (mask(y, x_shifted))
-                dst.x = op(src1.x, src2.x);
-            if (mask(y, x_shifted + 1))
-                dst.y = op(src1.y, src2.y);
-            if (mask(y, x_shifted + 2))
-                dst.z = op(src1.z, src2.z);
-            if (mask(y, x_shifted + 3))
-                dst.w = op(src1.w, src2.w);
-        }
-    };
-
-    template <typename T, typename D, typename UnOp, typename Mask>
-    __global__ static void transformSmart(const DevMem2D_<T> src_, PtrStep_<D> dst_, const Mask mask, UnOp op)
-    {
-        typedef typename UnReadWriteTraits<T, D>::read_type read_type;
-        typedef typename UnReadWriteTraits<T, D>::write_type write_type;
-        const int shift = UnReadWriteTraits<T, D>::shift;
-
-        const int x = threadIdx.x + blockIdx.x * blockDim.x;
-        const int y = threadIdx.y + blockIdx.y * blockDim.y;
-        const int x_shifted = x * shift;
-
-        if (y < src_.rows)
-        {
-            const T* src = src_.ptr(y);
-            D* dst = dst_.ptr(y);
-
-            if (x_shifted + shift - 1 < src_.cols)
-            {
-                read_type src_n_el = ((const read_type*)src)[x];
-                write_type dst_n_el;
-
-                OpUnroller<shift>::unroll(src_n_el, dst_n_el, mask, op, x_shifted, y);
-
-                ((write_type*)dst)[x] = dst_n_el;
-            }
-            else
-            {
-                for (int real_x = x_shifted; real_x < src_.cols; ++real_x)
-                {
-                    if (mask(y, real_x))
-                        dst[real_x] = op(src[real_x]);
-                }
-            }
-        }
+        detail::transform_caller(src, dst, op, detail::MaskReader(mask), stream);
     }
 
-    template <typename T, typename D, typename UnOp, typename Mask>
-    static __global__ void transformSimple(const DevMem2D_<T> src, PtrStep_<D> dst, const Mask mask, UnOp op)
+    template <typename T1, typename T2, typename D, typename BinOp>
+    static void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
+        const BinOp& op, cudaStream_t stream = 0)
     {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < src.cols && y < src.rows && mask(y, x))
-        {
-            dst.ptr(y)[x] = op(src.ptr(y)[x]);
-        }
+        detail::transform_caller(src1, src2, dst, op, detail::NoMask(), stream);
     }
-
-    template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-    __global__ static void transformSmart(const DevMem2D_<T1> src1_, const PtrStep_<T2> src2_, PtrStep_<D> dst_, 
-        const Mask mask, BinOp op)
+    template <typename T1, typename T2, typename D, typename BinOp>
+    static void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
+        const PtrStep& mask, const BinOp& op, cudaStream_t stream = 0)
     {
-        typedef typename BinReadWriteTraits<T1, T2, D>::read_type1 read_type1;
-        typedef typename BinReadWriteTraits<T1, T2, D>::read_type2 read_type2;
-        typedef typename BinReadWriteTraits<T1, T2, D>::write_type write_type;
-        const int shift = BinReadWriteTraits<T1, T2, D>::shift;
-
-        const int x = threadIdx.x + blockIdx.x * blockDim.x;
-        const int y = threadIdx.y + blockIdx.y * blockDim.y;
-        const int x_shifted = x * shift;
-
-        if (y < src1_.rows)
-        {
-            const T1* src1 = src1_.ptr(y);
-            const T2* src2 = src2_.ptr(y);
-            D* dst = dst_.ptr(y);
-
-            if (x_shifted + shift - 1 < src1_.cols)
-            {
-                read_type1 src1_n_el = ((const read_type1*)src1)[x];
-                read_type2 src2_n_el = ((const read_type2*)src2)[x];
-                write_type dst_n_el;
-                
-                OpUnroller<shift>::unroll(src1_n_el, src2_n_el, dst_n_el, mask, op, x_shifted, y);
-
-                ((write_type*)dst)[x] = dst_n_el;
-            }
-            else
-            {
-                for (int real_x = x_shifted; real_x < src1_.cols; ++real_x)
-                {
-                    if (mask(y, real_x))
-                        dst[real_x] = op(src1[real_x], src2[real_x]);
-                }
-            }
-        }
+        detail::transform_caller(src1, src2, dst, op, detail::MaskReader(mask), stream);
     }
-
-    template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-    static __global__ void transformSimple(const DevMem2D_<T1> src1, const PtrStep_<T2> src2, PtrStep_<D> dst, 
-        const Mask mask, BinOp op)
-    {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < src1.cols && y < src1.rows && mask(y, x))
-        {
-            T1 src1_data = src1.ptr(y)[x];
-            T2 src2_data = src2.ptr(y)[x];
-            dst.ptr(y)[x] = op(src1_data, src2_data);
-        }
-    }  
 }}}
 
-namespace cv 
-{ 
-    namespace gpu 
-    {
-        template <bool UseSmart> struct TransformDispatcher;
-        template<> struct TransformDispatcher<false>
-        {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, 
-                             cudaStream_t stream = 0)
-            {
-                dim3 threads(16, 16, 1);
-                dim3 grid(1, 1, 1);
-
-                grid.x = divUp(src.cols, threads.x);
-                grid.y = divUp(src.rows, threads.y);        
-
-                device::transformSimple<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
-
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() ); 
-            }
-
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
-                             BinOp op, const Mask& mask, cudaStream_t stream = 0)
-            {
-                dim3 threads(16, 16, 1);
-                dim3 grid(1, 1, 1);
-
-                grid.x = divUp(src1.cols, threads.x);
-                grid.y = divUp(src1.rows, threads.y);        
-
-                device::transformSimple<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
-
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );            
-            }
-        };
-        template<> struct TransformDispatcher<true>
-        {
-            template <typename T, typename D, typename UnOp, typename Mask>
-            static void call(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, 
-                             cudaStream_t stream = 0)
-            {
-                const int shift = device::UnReadWriteTraits<T, D>::shift;
-
-                dim3 threads(16, 16, 1);
-                dim3 grid(1, 1, 1);            
-
-                grid.x = divUp(src.cols, threads.x * shift);
-                grid.y = divUp(src.rows, threads.y);        
-
-                device::transformSmart<T, D><<<grid, threads, 0, stream>>>(src, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
-
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );
-            }
-
-            template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-            static void call(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
-                             BinOp op, const Mask& mask, cudaStream_t stream = 0)
-            {
-                const int shift = device::BinReadWriteTraits<T1, T2, D>::shift;
-
-                dim3 threads(16, 16, 1);
-                dim3 grid(1, 1, 1);
-
-                grid.x = divUp(src1.cols, threads.x * shift);
-                grid.y = divUp(src1.rows, threads.y);        
-
-                device::transformSmart<T1, T2, D><<<grid, threads, 0, stream>>>(src1, src2, dst, mask, op);
-                cudaSafeCall( cudaGetLastError() );
-
-                if (stream == 0)
-                    cudaSafeCall( cudaDeviceSynchronize() );            
-            }
-        };
-
-        template <typename T, typename D, int scn, int dcn> struct UseSmartUn_
-        {
-            static const bool value = false;
-        };
-        template <typename T, typename D> struct UseSmartUn_<T, D, 1, 1>
-        {
-            static const bool value = device::UnReadWriteTraits<T, D>::shift != 1;
-        };
-        template <typename T, typename D> struct UseSmartUn
-        {
-            static const bool value = UseSmartUn_<T, D, device::VecTraits<T>::cn, device::VecTraits<D>::cn>::value;
-        };
-
-        template <typename T1, typename T2, typename D, int src1cn, int src2cn, int dstcn> struct UseSmartBin_
-        {
-            static const bool value = false;
-        };
-        template <typename T1, typename T2, typename D> struct UseSmartBin_<T1, T2, D, 1, 1, 1>
-        {
-            static const bool value = device::BinReadWriteTraits<T1, T2, D>::shift != 1;
-        };
-        template <typename T1, typename T2, typename D> struct UseSmartBin
-        {
-            static const bool value = UseSmartBin_<T1, T2, D, device::VecTraits<T1>::cn, device::VecTraits<T2>::cn, device::VecTraits<D>::cn>::value;
-        };
-
-        template <typename T, typename D, typename UnOp, typename Mask>
-        static void transform_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, const Mask& mask, 
-            cudaStream_t stream = 0)
-        {
-            TransformDispatcher< UseSmartUn<T, D>::value >::call(src, dst, op, mask, stream);
-        }
-
-        template <typename T, typename D, typename UnOp>
-        static void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, UnOp op, cudaStream_t stream = 0)
-        {
-            transform_caller(src, dst, op, device::NoMask(), stream);
-        }
-        template <typename T, typename D, typename UnOp>
-        static void transform(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, const PtrStep& mask, UnOp op, 
-            cudaStream_t stream = 0)
-        {
-            transform_caller(src, dst, op, device::MaskReader(mask), stream);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp, typename Mask>
-        static void transform_caller(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
-            BinOp op, const Mask& mask, cudaStream_t stream = 0)
-        {
-            TransformDispatcher< UseSmartBin<T1, T2, D>::value >::call(src1, src2, dst, op, mask, stream);
-        }
-
-        template <typename T1, typename T2, typename D, typename BinOp>
-        static void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
-            BinOp op, cudaStream_t stream = 0)
-        {
-            transform_caller(src1, src2, dst, op, device::NoMask(), stream);
-        }
-        template <typename T1, typename T2, typename D, typename BinOp>
-        static void transform(const DevMem2D_<T1>& src1, const DevMem2D_<T2>& src2, const DevMem2D_<D>& dst, 
-            const PtrStep& mask, BinOp op, cudaStream_t stream = 0)
-        {
-            transform_caller(src1, src2, dst, op, device::MaskReader(mask), stream);
-        }
-    }
-}
-
 #endif // __OPENCV_GPU_TRANSFORM_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/utility.hpp b/modules/gpu/src/opencv2/gpu/device/utility.hpp
new file mode 100644
index 0000000000..b0dca8afeb
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/utility.hpp
@@ -0,0 +1,206 @@
+/*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_GPU_UTILITY_HPP__
+#define __OPENCV_GPU_UTILITY_HPP__
+
+#include "internal_shared.hpp"
+#include "saturate_cast.hpp"
+
+#ifndef __CUDA_ARCH__
+	#define __CUDA_ARCH__ 0
+#endif
+
+#define OPENCV_GPU_LOG_WARP_SIZE	    (5)
+#define OPENCV_GPU_WARP_SIZE	        (1 << OPENCV_GPU_LOG_WARP_SIZE)
+#define OPENCV_GPU_LOG_MEM_BANKS        ((__CUDA_ARCH__ >= 200) ? 5 : 4) // 32 banks on fermi, 16 on tesla
+#define OPENCV_GPU_MEM_BANKS            (1 << OPENCV_GPU_LOG_MEM_BANKS)
+
+#if defined(_WIN64) || defined(__LP64__)		
+    // 64-bit register modifier for inlined asm
+    #define OPENCV_GPU_ASM_PTR "l"
+#else	
+    // 32-bit register modifier for inlined asm
+    #define OPENCV_GPU_ASM_PTR "r"
+#endif
+
+namespace cv {  namespace gpu { namespace device
+{
+    template <typename T> void __host__ __device__ __forceinline__ swap(T& a, T& b) 
+    {
+        const T temp = a;
+        a = b;
+        b = temp;
+    }
+
+    // warp-synchronous 32 elements reduction
+    template <typename T, typename Op> __device__ __forceinline__ void warpReduce32(volatile T* data, T& partial_reduction, int tid, const Op& op)
+    {
+        data[tid] = partial_reduction;
+
+        if (tid < 16)
+        {
+            data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
+            data[tid] = partial_reduction = op(partial_reduction, data[tid + 8 ]);
+            data[tid] = partial_reduction = op(partial_reduction, data[tid + 4 ]);
+            data[tid] = partial_reduction = op(partial_reduction, data[tid + 2 ]);
+            data[tid] = partial_reduction = op(partial_reduction, data[tid + 1 ]);
+        }
+    }
+
+    // warp-synchronous 16 elements reduction
+    template <typename T, typename Op> __device__ __forceinline__ void warpReduce16(volatile T* data, T& partial_reduction, int tid, const Op& op)
+    {
+        data[tid] = partial_reduction;
+
+        if (tid < 8)
+        {
+            data[tid] = partial_reduction = op(partial_reduction, (T)data[tid + 8 ]);
+            data[tid] = partial_reduction = op(partial_reduction, (T)data[tid + 4 ]);
+            data[tid] = partial_reduction = op(partial_reduction, (T)data[tid + 2 ]);
+            data[tid] = partial_reduction = op(partial_reduction, (T)data[tid + 1 ]);
+        }
+    }
+
+    // warp-synchronous reduction
+    template <int n, typename T, typename Op> __device__ __forceinline__ void warpReduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+    {
+        if (tid < n)
+            data[tid] = partial_reduction;
+
+        if (n > 16)
+        {
+            if (tid < n - 16) 
+                data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
+            if (tid < 8)
+            {
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
+            }
+        }
+        else if (n > 8)
+        {
+            if (tid < n - 8) 
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
+            if (tid < 4)
+            {
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
+            }
+        }
+        else if (n > 4)
+        {
+            if (tid < n - 4) 
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
+            if (tid < 2)
+            {
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
+            }
+        }   
+        else if (n > 2)
+        {
+            if (tid < n - 2) 
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
+            if (tid < 2)
+            {
+                data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
+            }
+        }      
+    }
+
+    // solve 2x2 linear system Ax=b
+    template <typename T> __device__ __forceinline__ bool solve2x2(const T A[2][2], const T b[2], T x[2])
+    {
+        T det = A[0][0] * A[1][1] - A[1][0] * A[0][1];
+
+        if (det != 0)
+        {
+            double invdet = 1.0 / det;
+
+            x[0] = saturate_cast<T>(invdet * (b[0] * A[1][1] - b[1] * A[0][1]));
+
+            x[1] = saturate_cast<T>(invdet * (A[0][0] * b[1] - A[1][0] * b[0]));
+
+            return true;
+        }
+
+        return false;
+    }
+
+    // solve 3x3 linear system Ax=b
+    template <typename T> __device__ __forceinline__ bool solve3x3(const T A[3][3], const T b[3], T x[3])
+    {
+        T det = A[0][0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1])
+              - A[0][1] * (A[1][0] * A[2][2] - A[1][2] * A[2][0])
+              + A[0][2] * (A[1][0] * A[2][1] - A[1][1] * A[2][0]);
+
+        if (det != 0)
+        {
+            double invdet = 1.0 / det;
+
+            x[0] = saturate_cast<T>(invdet * 
+                (b[0]    * (A[1][1] * A[2][2] - A[1][2] * A[2][1]) -
+                 A[0][1] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) +
+                 A[0][2] * (b[1]    * A[2][1] - A[1][1] * b[2]   )));
+
+            x[1] = saturate_cast<T>(invdet * 
+                (A[0][0] * (b[1]    * A[2][2] - A[1][2] * b[2]   ) -
+                 b[0]    * (A[1][0] * A[2][2] - A[1][2] * A[2][0]) +
+                 A[0][2] * (A[1][0] * b[2]    - b[1]    * A[2][0])));
+
+            x[2] = saturate_cast<T>(invdet * 
+                (A[0][0] * (A[1][1] * b[2]    - b[1]    * A[2][1]) -
+                 A[0][1] * (A[1][0] * b[2]    - b[1]    * A[2][0]) +
+                 b[0]    * (A[1][0] * A[2][1] - A[1][1] * A[2][0])));
+
+            return true;
+        }
+
+        return false;
+    }
+}}}
+
+#endif // __OPENCV_GPU_UTILITY_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/vec_math.hpp b/modules/gpu/src/opencv2/gpu/device/vec_math.hpp
new file mode 100644
index 0000000000..238f5c771e
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/vec_math.hpp
@@ -0,0 +1,287 @@
+/*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_GPU_VECMATH_HPP__
+#define __OPENCV_GPU_VECMATH_HPP__
+
+#include "internal_shared.hpp"
+#include "saturate_cast.hpp"
+#include "vec_traits.hpp"
+#include "functional.hpp"
+
+namespace cv {  namespace gpu { namespace device
+{
+    namespace detail
+    {
+        template <int cn, typename VecD> struct SatCastHelper;
+        template <typename VecD> struct SatCastHelper<1, VecD>
+        {
+            template <typename VecS> static __device__ VecD cast(const VecS& v)
+            {
+                typedef typename VecTraits<VecD>::elem_type D;
+                return VecTraits<VecD>::make(saturate_cast<D>(v.x));
+            }
+        };
+        template <typename VecD> struct SatCastHelper<2, VecD>
+        {
+            template <typename VecS> static __device__ VecD cast(const VecS& v)
+            {
+                typedef typename VecTraits<VecD>::elem_type D;
+                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y));
+            }
+        };
+        template <typename VecD> struct SatCastHelper<3, VecD>
+        {
+            template <typename VecS> static __device__ VecD cast(const VecS& v)
+            {
+                typedef typename VecTraits<VecD>::elem_type D;
+                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z));
+            }
+        };
+        template <typename VecD> struct SatCastHelper<4, VecD>
+        {
+            template <typename VecS> static __device__ VecD cast(const VecS& v)
+            {
+                typedef typename VecTraits<VecD>::elem_type D;
+                return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z), saturate_cast<D>(v.w));
+            }
+        };
+
+        template <typename VecD, typename VecS> static __device__ VecD saturate_cast_caller(const VecS& v)
+        {
+            return SatCastHelper<VecTraits<VecD>::cn, VecD>::cast(v);
+        }
+    }
+
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uchar1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const char1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const ushort1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const short1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uint1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const int1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const float1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const double1& v) {return detail::saturate_cast_caller<_Tp>(v);}
+
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uchar2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const char2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const ushort2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const short2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uint2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const int2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const float2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const double2& v) {return detail::saturate_cast_caller<_Tp>(v);}
+
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uchar3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const char3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const ushort3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const short3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uint3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const int3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const float3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const double3& v) {return detail::saturate_cast_caller<_Tp>(v);}
+
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uchar4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const char4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const ushort4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const short4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const uint4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const int4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const float4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+    template<typename _Tp> static __device__ _Tp saturate_cast(const double4& v) {return detail::saturate_cast_caller<_Tp>(v);}
+
+#define OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, op, func) \
+    static __device__ TypeVec<func<type>::result_type, 1>::vec_type op(const type ## 1 & a) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 1>::vec_type>::make(f(a.x)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 2>::vec_type op(const type ## 2 & a) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 2>::vec_type>::make(f(a.x), f(a.y)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 3>::vec_type op(const type ## 3 & a) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 3>::vec_type>::make(f(a.x), f(a.y), f(a.z)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 4>::vec_type op(const type ## 4 & a) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 4>::vec_type>::make(f(a.x), f(a.y), f(a.z), f(a.w)); \
+    }
+
+#define OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, op, func) \
+    static __device__ TypeVec<func<type>::result_type, 1>::vec_type op(const type ## 1 & a, const type ## 1 & b) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 1>::vec_type>::make(f(a.x, b.x)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 1>::vec_type op(const type ## 1 & v, T s) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 1>::vec_type>::make(f(v.x, s)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 1>::vec_type op(T s, const type ## 1 & v) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 1>::vec_type>::make(f(s, v.x)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 2>::vec_type op(const type ## 2 & a, const type ## 2 & b) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 2>::vec_type>::make(f(a.x, b.x), f(a.y, b.y)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 2>::vec_type op(const type ## 2 & v, T s) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 2>::vec_type>::make(f(v.x, s), f(v.y, s)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 2>::vec_type op(T s, const type ## 2 & v) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 2>::vec_type>::make(f(s, v.x), f(s, v.y)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 3>::vec_type op(const type ## 3 & a, const type ## 3 & b) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 3>::vec_type>::make(f(a.x, b.x), f(a.y, b.y), f(a.z, b.z)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 3>::vec_type op(const type ## 3 & v, T s) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 3>::vec_type>::make(f(v.x, s), f(v.y, s), f(v.z, s)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 3>::vec_type op(T s, const type ## 3 & v) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 3>::vec_type>::make(f(s, v.x), f(s, v.y), f(s, v.z)); \
+    } \
+    static __device__ TypeVec<func<type>::result_type, 4>::vec_type op(const type ## 4 & a, const type ## 4 & b) \
+    { \
+        func<type> f; \
+        return VecTraits<TypeVec<func<type>::result_type, 4>::vec_type>::make(f(a.x, b.x), f(a.y, b.y), f(a.z, b.z), f(a.w, b.w)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 4>::vec_type op(const type ## 4 & v, T s) \
+    { \
+        func<typename BinOpTraits<type, T>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 4>::vec_type>::make(f(v.x, s), f(v.y, s), f(v.z, s), f(v.w, s)); \
+    } \
+    template <typename T> \
+    static __device__ typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 4>::vec_type op(T s, const type ## 4 & v) \
+    { \
+        func<typename BinOpTraits<T, type>::argument_type> f; \
+        return VecTraits<typename TypeVec<typename func<typename BinOpTraits<type, T>::argument_type>::result_type, 4>::vec_type>::make(f(s, v.x), f(s, v.y), f(s, v.z), f(s, v.w)); \
+    }
+
+#define OPENCV_GPU_IMPLEMENT_VEC_OP(type) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator +, plus) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator -, minus) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator *, multiplies) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator /, divides) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP (type, operator -, negate) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator ==, equal_to) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator !=, not_equal_to) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator > , greater) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator < , less) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator >=, greater_equal) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator <=, less_equal) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator &&, logical_and) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator ||, logical_or) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP (type, operator ! , logical_not) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, max, maximum) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, min, minimum) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, fabs, fabs_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, sqrt, sqrt_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, exp, exp_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, exp2, exp2_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, exp10, exp10_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, log, log_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, log2, log2_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, log10, log10_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, sin, sin_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, cos, cos_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, tan, tan_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, asin, asin_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, acos, acos_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, atan, atan_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, sinh, sinh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, cosh, cosh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, tanh, tanh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, asinh, asinh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, acosh, acosh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, atanh, atanh_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, hypot, hypot_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, atan2, atan2_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, pow, pow_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, hypot_sqr, hypot_sqr_func)
+
+#define OPENCV_GPU_IMPLEMENT_VEC_INT_OP(type) \
+    OPENCV_GPU_IMPLEMENT_VEC_OP(type) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator &, bit_and) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator |, bit_or) \
+    OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, operator ^, bit_xor) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP (type, operator ~, bit_not)
+
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uchar)
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(char)
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(ushort)
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(short)
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(int)
+    OPENCV_GPU_IMPLEMENT_VEC_INT_OP(uint)
+    OPENCV_GPU_IMPLEMENT_VEC_OP(float)
+    OPENCV_GPU_IMPLEMENT_VEC_OP(double)
+
+#undef OPENCV_GPU_IMPLEMENT_VEC_UNOP
+#undef OPENCV_GPU_IMPLEMENT_VEC_BINOP
+#undef OPENCV_GPU_IMPLEMENT_VEC_OP
+#undef OPENCV_GPU_IMPLEMENT_VEC_INT_OP
+}}}
+        
+#endif // __OPENCV_GPU_VECMATH_HPP__
\ No newline at end of file
diff --git a/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp b/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp
new file mode 100644
index 0000000000..62d3710620
--- /dev/null
+++ b/modules/gpu/src/opencv2/gpu/device/vec_traits.hpp
@@ -0,0 +1,142 @@
+/*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_GPU_VEC_TRAITS_HPP__
+#define __OPENCV_GPU_VEC_TRAITS_HPP__
+
+#include "internal_shared.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    template<typename T, int N> struct TypeVec;
+
+#define OPENCV_GPU_IMPLEMENT_TYPE_VEC(type) \
+    template<> struct TypeVec<type, 1> { typedef type vec_type; }; \
+    template<> struct TypeVec<type ## 1, 1> { typedef type ## 1 vec_type; }; \
+    template<> struct TypeVec<type, 2> { typedef type ## 2 vec_type; }; \
+    template<> struct TypeVec<type ## 2, 2> { typedef type ## 2 vec_type; }; \
+    template<> struct TypeVec<type, 3> { typedef type ## 3 vec_type; }; \
+    template<> struct TypeVec<type ## 3, 3> { typedef type ## 3 vec_type; }; \
+    template<> struct TypeVec<type, 4> { typedef type ## 4 vec_type; }; \
+    template<> struct TypeVec<type ## 4, 4> { typedef type ## 4 vec_type; };
+
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(uchar)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(char)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(ushort)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(short)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(int)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(uint)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(float)
+    OPENCV_GPU_IMPLEMENT_TYPE_VEC(double)
+
+#undef OPENCV_GPU_IMPLEMENT_TYPE_VEC
+
+    template<> struct TypeVec<schar, 1> { typedef schar vec_type; };
+    template<> struct TypeVec<schar, 2> { typedef char2 vec_type; };
+    template<> struct TypeVec<schar, 3> { typedef char3 vec_type; };
+    template<> struct TypeVec<schar, 4> { typedef char4 vec_type; };
+
+    template<> struct TypeVec<bool, 1> { typedef uchar vec_type; };
+    template<> struct TypeVec<bool, 2> { typedef uchar2 vec_type; };
+    template<> struct TypeVec<bool, 3> { typedef uchar3 vec_type; };
+    template<> struct TypeVec<bool, 4> { typedef uchar4 vec_type; };
+
+    template<typename T> struct VecTraits;
+
+#define OPENCV_GPU_IMPLEMENT_VEC_TRAITS(type) \
+    template<> struct VecTraits<type> \
+    { \
+        typedef type elem_type; \
+        enum {cn=1}; \
+        static __device__ __host__ type all(type v) {return v;} \
+        static __device__ __host__ type make(type x) {return x;} \
+    }; \
+    template<> struct VecTraits<type ## 1> \
+    { \
+        typedef type elem_type; \
+        enum {cn=1}; \
+        static __device__ __host__ type ## 1 all(type v) {return make_ ## type ## 1(v);} \
+        static __device__ __host__ type ## 1 make(type x) {return make_ ## type ## 1(x);} \
+    }; \
+    template<> struct VecTraits<type ## 2> \
+    { \
+        typedef type elem_type; \
+        enum {cn=2}; \
+        static __device__ __host__ type ## 2 all(type v) {return make_ ## type ## 2(v, v);} \
+        static __device__ __host__ type ## 2 make(type x, type y) {return make_ ## type ## 2(x, y);} \
+    }; \
+    template<> struct VecTraits<type ## 3> \
+    { \
+        typedef type elem_type; \
+        enum {cn=3}; \
+        static __device__ __host__ type ## 3 all(type v) {return make_ ## type ## 3(v, v, v);} \
+        static __device__ __host__ type ## 3 make(type x, type y, type z) {return make_ ## type ## 3(x, y, z);} \
+    }; \
+    template<> struct VecTraits<type ## 4> \
+    { \
+        typedef type elem_type; \
+        enum {cn=4}; \
+        static __device__ __host__ type ## 4 all(type v) {return make_ ## type ## 4(v, v, v, v);} \
+        static __device__ __host__ type ## 4 make(type x, type y, type z, type w) {return make_ ## type ## 4(x, y, z, w);} \
+    };
+
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uchar)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(char)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(ushort)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(short)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(int)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(uint)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(float)
+    OPENCV_GPU_IMPLEMENT_VEC_TRAITS(double)
+
+#undef OPENCV_GPU_IMPLEMENT_VEC_TRAITS
+
+    template<> struct VecTraits<schar> 
+    { 
+        typedef schar elem_type; 
+        enum {cn=1}; 
+        static __device__ __host__ schar all(schar v) {return v;}
+        static __device__ __host__ schar make(schar x) {return x;}
+    };
+}}}
+
+#endif // __OPENCV_GPU_VEC_TRAITS_HPP__
diff --git a/modules/gpu/src/opencv2/gpu/device/vecmath.hpp b/modules/gpu/src/opencv2/gpu/device/vecmath.hpp
deleted file mode 100644
index 8456861b90..0000000000
--- a/modules/gpu/src/opencv2/gpu/device/vecmath.hpp
+++ /dev/null
@@ -1,1097 +0,0 @@
-/*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_GPU_VECMATH_HPP__
-#define __OPENCV_GPU_VECMATH_HPP__
-
-#include "internal_shared.hpp"
-#include "saturate_cast.hpp"
-
-namespace cv
-{
-    namespace gpu
-    {
-        namespace device
-        {
-            template<typename T, int N> struct TypeVec;
-
-            template<> struct TypeVec<uchar, 1> { typedef uchar vec_t; };
-            template<> struct TypeVec<uchar1, 1> { typedef uchar1 vec_t; };
-            template<> struct TypeVec<uchar, 2> { typedef uchar2 vec_t; };
-            template<> struct TypeVec<uchar2, 2> { typedef uchar2 vec_t; };
-            template<> struct TypeVec<uchar, 3> { typedef uchar3 vec_t; };
-            template<> struct TypeVec<uchar3, 3> { typedef uchar3 vec_t; };
-            template<> struct TypeVec<uchar, 4> { typedef uchar4 vec_t; };
-            template<> struct TypeVec<uchar4, 4> { typedef uchar4 vec_t; };
-
-            template<> struct TypeVec<char, 1> { typedef char vec_t; };
-            template<> struct TypeVec<schar, 1> { typedef char vec_t; };
-            template<> struct TypeVec<char1, 1> { typedef char1 vec_t; };
-            template<> struct TypeVec<char, 2> { typedef char2 vec_t; };
-            template<> struct TypeVec<schar, 2> { typedef char2 vec_t; };
-            template<> struct TypeVec<char2, 2> { typedef char2 vec_t; };
-            template<> struct TypeVec<char, 3> { typedef char3 vec_t; };
-            template<> struct TypeVec<schar, 3> { typedef char3 vec_t; };
-            template<> struct TypeVec<char3, 3> { typedef char3 vec_t; };
-            template<> struct TypeVec<char, 4> { typedef char4 vec_t; };
-            template<> struct TypeVec<schar, 4> { typedef char4 vec_t; };
-            template<> struct TypeVec<char4, 4> { typedef char4 vec_t; };
-
-            template<> struct TypeVec<ushort, 1> { typedef ushort vec_t; };
-            template<> struct TypeVec<ushort1, 1> { typedef ushort1 vec_t; };
-            template<> struct TypeVec<ushort, 2> { typedef ushort2 vec_t; };
-            template<> struct TypeVec<ushort2, 2> { typedef ushort2 vec_t; };
-            template<> struct TypeVec<ushort, 3> { typedef ushort3 vec_t; };
-            template<> struct TypeVec<ushort3, 3> { typedef ushort3 vec_t; };
-            template<> struct TypeVec<ushort, 4> { typedef ushort4 vec_t; };
-            template<> struct TypeVec<ushort4, 4> { typedef ushort4 vec_t; };
-
-            template<> struct TypeVec<short, 1> { typedef short vec_t; };
-            template<> struct TypeVec<short1, 1> { typedef short1 vec_t; };
-            template<> struct TypeVec<short, 2> { typedef short2 vec_t; };
-            template<> struct TypeVec<short2, 2> { typedef short2 vec_t; };
-            template<> struct TypeVec<short, 3> { typedef short3 vec_t; };
-            template<> struct TypeVec<short3, 3> { typedef short3 vec_t; };
-            template<> struct TypeVec<short, 4> { typedef short4 vec_t; };
-            template<> struct TypeVec<short4, 4> { typedef short4 vec_t; };
-
-            template<> struct TypeVec<uint, 1> { typedef uint vec_t; };
-            template<> struct TypeVec<uint1, 1> { typedef uint1 vec_t; };
-            template<> struct TypeVec<uint, 2> { typedef uint2 vec_t; };
-            template<> struct TypeVec<uint2, 2> { typedef uint2 vec_t; };
-            template<> struct TypeVec<uint, 3> { typedef uint3 vec_t; };
-            template<> struct TypeVec<uint3, 3> { typedef uint3 vec_t; };
-            template<> struct TypeVec<uint, 4> { typedef uint4 vec_t; };
-            template<> struct TypeVec<uint4, 4> { typedef uint4 vec_t; };
-
-            template<> struct TypeVec<int, 1> { typedef int vec_t; };
-            template<> struct TypeVec<int1, 1> { typedef int1 vec_t; };
-            template<> struct TypeVec<int, 2> { typedef int2 vec_t; };
-            template<> struct TypeVec<int2, 2> { typedef int2 vec_t; };
-            template<> struct TypeVec<int, 3> { typedef int3 vec_t; };
-            template<> struct TypeVec<int3, 3> { typedef int3 vec_t; };
-            template<> struct TypeVec<int, 4> { typedef int4 vec_t; };
-            template<> struct TypeVec<int4, 4> { typedef int4 vec_t; };
-
-            template<> struct TypeVec<float, 1> { typedef float vec_t; };
-            template<> struct TypeVec<float1, 1> { typedef float1 vec_t; };
-            template<> struct TypeVec<float, 2> { typedef float2 vec_t; };
-            template<> struct TypeVec<float2, 2> { typedef float2 vec_t; };
-            template<> struct TypeVec<float, 3> { typedef float3 vec_t; };
-            template<> struct TypeVec<float3, 3> { typedef float3 vec_t; };
-            template<> struct TypeVec<float, 4> { typedef float4 vec_t; };
-            template<> struct TypeVec<float4, 4> { typedef float4 vec_t; };
-
-            template<> struct TypeVec<double, 1> { typedef double vec_t; };
-            template<> struct TypeVec<double1, 1> { typedef double1 vec_t; };
-            template<> struct TypeVec<double, 2> { typedef double2 vec_t; };
-            template<> struct TypeVec<double2, 2> { typedef double2 vec_t; };
-            template<> struct TypeVec<double, 3> { typedef double3 vec_t; };
-            template<> struct TypeVec<double3, 3> { typedef double3 vec_t; };
-            template<> struct TypeVec<double, 4> { typedef double4 vec_t; };
-            template<> struct TypeVec<double4, 4> { typedef double4 vec_t; };
-
-            template<typename T> struct VecTraits;
-
-            template<> struct VecTraits<uchar> 
-            { 
-                typedef uchar elem_t; 
-                enum {cn=1};
-                static __device__ __forceinline__ __host__ uchar all(uchar v) {return v;}
-                static __device__ __forceinline__ __host__ uchar make(uchar x) {return x;}
-            };
-            template<> struct VecTraits<uchar1> 
-            { 
-                typedef uchar elem_t; 
-                enum {cn=1};
-                static __device__ __forceinline__ __host__ uchar1 all(uchar v) {return make_uchar1(v);}
-                static __device__ __forceinline__ __host__ uchar1 make(uchar x) {return make_uchar1(x);}
-            };
-            template<> struct VecTraits<uchar2> 
-            { 
-                typedef uchar elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ uchar2 all(uchar v) {return make_uchar2(v, v);}
-                static __device__ __forceinline__ __host__ uchar2 make(uchar x, uchar y) {return make_uchar2(x, y);}
-            };
-            template<> struct VecTraits<uchar3> 
-            { 
-                typedef uchar elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ uchar3 all(uchar v) {return make_uchar3(v, v, v);}
-                static __device__ __forceinline__ __host__ uchar3 make(uchar x, uchar y, uchar z) {return make_uchar3(x, y, z);}
-            };
-            template<> struct VecTraits<uchar4> 
-            { 
-                typedef uchar elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ uchar4 all(uchar v) {return make_uchar4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ uchar4 make(uchar x, uchar y, uchar z, uchar w) {return make_uchar4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<char> 
-            { 
-                typedef char elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ char all(char v) {return v;}
-                static __device__ __forceinline__ __host__ char make(char x) {return x;}
-            };
-            template<> struct VecTraits<schar> 
-            { 
-                typedef schar elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ schar all(schar v) {return v;}
-                static __device__ __forceinline__ __host__ schar make(schar x) {return x;}
-            };
-            template<> struct VecTraits<char1> 
-            { 
-                typedef schar elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ char1 all(schar v) {return make_char1(v);}
-                static __device__ __forceinline__ __host__ char1 make(schar x) {return make_char1(x);}
-            };
-            template<> struct VecTraits<char2> 
-            { 
-                typedef schar elem_t; 
-                enum {cn=2}; 
-                static  __device__ __forceinline__ __host__ char2 all(schar v) {return make_char2(v, v);}
-                static  __device__ __forceinline__ __host__ char2 make(schar x, schar y) {return make_char2(x, y);}
-            };
-            template<> struct VecTraits<char3> 
-            { 
-                typedef schar elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ char3 all(schar v) {return make_char3(v, v, v);}
-                static __device__ __forceinline__ __host__ char3 make(schar x, schar y, schar z) {return make_char3(x, y, z);}
-            };
-            template<> struct VecTraits<char4> 
-            { 
-                typedef schar elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ char4 all(schar v) {return make_char4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ char4 make(schar x, schar y, schar z, schar w) {return make_char4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<ushort> 
-            { 
-                typedef ushort elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ ushort all(ushort v) {return v;}
-                static __device__ __forceinline__ __host__ ushort make(ushort x) {return x;}
-            };
-            template<> struct VecTraits<ushort1> 
-            { 
-                typedef ushort elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ ushort1 all(ushort v) {return make_ushort1(v);}
-                static __device__ __forceinline__ __host__ ushort1 make(ushort x) {return make_ushort1(x);}
-            };
-            template<> struct VecTraits<ushort2> 
-            { 
-                typedef ushort elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ ushort2 all(ushort v) {return make_ushort2(v, v);}
-                static __device__ __forceinline__ __host__ ushort2 make(ushort x, ushort y) {return make_ushort2(x, y);}
-            };
-            template<> struct VecTraits<ushort3> 
-            { 
-                typedef ushort elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ ushort3 all(ushort v) {return make_ushort3(v, v, v);}
-                static __device__ __forceinline__ __host__ ushort3 make(ushort x, ushort y, ushort z) {return make_ushort3(x, y, z);}
-            };
-            template<> struct VecTraits<ushort4> 
-            { 
-                typedef ushort elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ ushort4 all(ushort v) {return make_ushort4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ ushort4 make(ushort x, ushort y, ushort z, ushort w) {return make_ushort4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<short> 
-            { 
-                typedef short elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ short all(short v) {return v;}
-                static __device__ __forceinline__ __host__ short make(short x) {return x;}
-            };
-            template<> struct VecTraits<short1> 
-            { 
-                typedef short elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ short1 all(short v) {return make_short1(v);}
-                static __device__ __forceinline__ __host__ short1 make(short x) {return make_short1(x);}
-            };
-            template<> struct VecTraits<short2> 
-            { 
-                typedef short elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ short2 all(short v) {return make_short2(v, v);}
-                static __device__ __forceinline__ __host__ short2 make(short x, short y) {return make_short2(x, y);}
-            };
-            template<> struct VecTraits<short3> 
-            { 
-                typedef short elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ short3 all(short v) {return make_short3(v, v, v);}
-                static __device__ __forceinline__ __host__ short3 make(short x, short y, short z) {return make_short3(x, y, z);}
-            };
-            template<> struct VecTraits<short4> 
-            { 
-                typedef short elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ short4 all(short v) {return make_short4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ short4 make(short x, short y, short z, short w) {return make_short4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<uint> 
-            { 
-                typedef uint elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ uint all(uint v) {return v;}
-                static __device__ __forceinline__ __host__ uint make(uint x) {return x;}
-            };
-            template<> struct VecTraits<uint1> 
-            { 
-                typedef uint elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ uint1 all(uint v) {return make_uint1(v);}
-                static __device__ __forceinline__ __host__ uint1 make(uint x) {return make_uint1(x);}
-            };
-            template<> struct VecTraits<uint2> 
-            { 
-                typedef uint elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ uint2 all(uint v) {return make_uint2(v, v);}
-                static __device__ __forceinline__ __host__ uint2 make(uint x, uint y) {return make_uint2(x, y);}
-            };
-            template<> struct VecTraits<uint3> 
-            { 
-                typedef uint elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ uint3 all(uint v) {return make_uint3(v, v, v);}
-                static __device__ __forceinline__ __host__ uint3 make(uint x, uint y, uint z) {return make_uint3(x, y, z);}
-            };
-            template<> struct VecTraits<uint4> 
-            { 
-                typedef uint elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ uint4 all(uint v) {return make_uint4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ uint4 make(uint x, uint y, uint z, uint w) {return make_uint4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<int> 
-            { 
-                typedef int elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ int all(int v) {return v;}
-                static __device__ __forceinline__ __host__ int make(int x) {return x;}
-            };
-            template<> struct VecTraits<int1> 
-            { 
-                typedef int elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ int1 all(int v) {return make_int1(v);}
-                static __device__ __forceinline__ __host__ int1 make(int x) {return make_int1(x);}
-            };
-            template<> struct VecTraits<int2> 
-            { 
-                typedef int elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ int2 all(int v) {return make_int2(v, v);}
-                static __device__ __forceinline__ __host__ int2 make(int x, int y) {return make_int2(x, y);}
-            };
-            template<> struct VecTraits<int3> 
-            { 
-                typedef int elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ int3 all(int v) {return make_int3(v, v, v);}
-                static __device__ __forceinline__ __host__ int3 make(int x, int y, int z) {return make_int3(x, y, z);}
-            };
-            template<> struct VecTraits<int4> 
-            { 
-                typedef int elem_t; 
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ int4 all(int v) {return make_int4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ int4 make(int x, int y, int z, int w) {return make_int4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<float> 
-            { 
-                typedef float elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ float all(float v) {return v;}
-                static __device__ __forceinline__ __host__ float make(float x) {return x;}
-            };
-            template<> struct VecTraits<float1> 
-            { 
-                typedef float elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ float1 all(float v) {return make_float1(v);}
-                static __device__ __forceinline__ __host__ float1 make(float x) {return make_float1(x);}
-            };
-            template<> struct VecTraits<float2> 
-            { 
-                typedef float elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ float2 all(float v) {return make_float2(v, v);}
-                static __device__ __forceinline__ __host__ float2 make(float x, float y) {return make_float2(x, y);}
-            };
-            template<> struct VecTraits<float3> 
-            { 
-                typedef float elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ float3 all(float v) {return make_float3(v, v, v);}
-                static __device__ __forceinline__ __host__ float3 make(float x, float y, float z) {return make_float3(x, y, z);}
-            };
-            template<> struct VecTraits<float4> 
-            { 
-                typedef float elem_t;
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ float4 all(float v) {return make_float4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ float4 make(float x, float y, float z, float w) {return make_float4(x, y, z, w);}
-            };
-
-            template<> struct VecTraits<double> 
-            { 
-                typedef double elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ double all(double v) {return v;}
-                static __device__ __forceinline__ __host__ double make(double x) {return x;}
-            };
-            template<> struct VecTraits<double1> 
-            { 
-                typedef double elem_t; 
-                enum {cn=1}; 
-                static __device__ __forceinline__ __host__ double1 all(double v) {return make_double1(v);}
-                static __device__ __forceinline__ __host__ double1 make(double x) {return make_double1(x);}
-            };
-            template<> struct VecTraits<double2> 
-            { 
-                typedef double elem_t; 
-                enum {cn=2}; 
-                static __device__ __forceinline__ __host__ double2 all(double v) {return make_double2(v, v);}
-                static __device__ __forceinline__ __host__ double2 make(double x, double y) {return make_double2(x, y);}
-            };
-            template<> struct VecTraits<double3> 
-            { 
-                typedef double elem_t; 
-                enum {cn=3}; 
-                static __device__ __forceinline__ __host__ double3 all(double v) {return make_double3(v, v, v);}
-                static __device__ __forceinline__ __host__ double3 make(double x, double y, double z) {return make_double3(x, y, z);}
-            };
-            template<> struct VecTraits<double4> 
-            { 
-                typedef double elem_t;
-                enum {cn=4}; 
-                static __device__ __forceinline__ __host__ double4 all(double v) {return make_double4(v, v, v, v);}
-                static __device__ __forceinline__ __host__ double4 make(double x, double y, double z, double w) {return make_double4(x, y, z, w);}
-            };
-
-            template <int cn, typename VecD> struct SatCast;
-            template <typename VecD> struct SatCast<1, VecD>
-            {
-                template <typename VecS>
-                static __device__ __forceinline__ VecD cast(const VecS& v)
-                {
-                    typedef typename VecTraits<VecD>::elem_t D;
-                    return VecTraits<VecD>::make(saturate_cast<D>(v.x));
-                }
-            };
-            template <typename VecD> struct SatCast<2, VecD>
-            {
-                template <typename VecS>
-                static __device__ __forceinline__ VecD cast(const VecS& v)
-                {
-                    typedef typename VecTraits<VecD>::elem_t D;
-                    return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y));
-                }
-            };
-            template <typename VecD> struct SatCast<3, VecD>
-            {
-                template <typename VecS>
-                static __device__ __forceinline__ VecD cast(const VecS& v)
-                {
-                    typedef typename VecTraits<VecD>::elem_t D;
-                    return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z));
-                }
-            };
-            template <typename VecD> struct SatCast<4, VecD>
-            {
-                template <typename VecS>
-                static __device__ __forceinline__ VecD cast(const VecS& v)
-                {
-                    typedef typename VecTraits<VecD>::elem_t D;
-                    return VecTraits<VecD>::make(saturate_cast<D>(v.x), saturate_cast<D>(v.y), saturate_cast<D>(v.z), saturate_cast<D>(v.w));
-                }
-            };
-
-            template <typename VecD, typename VecS> static __device__ __forceinline__ VecD saturate_cast_caller(const VecS& v)
-            {
-                return SatCast<VecTraits<VecD>::cn, VecD>::cast(v);
-            }
-
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int1& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float1& v) {return saturate_cast_caller<_Tp>(v);}
-
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int2& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float2& v) {return saturate_cast_caller<_Tp>(v);}
-
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int3& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float3& v) {return saturate_cast_caller<_Tp>(v);}
-
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uchar4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const char4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const ushort4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const short4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const uint4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const int4& v) {return saturate_cast_caller<_Tp>(v);}
-            template<typename _Tp> static __device__ __forceinline__ _Tp saturate_cast(const float4& v) {return saturate_cast_caller<_Tp>(v);}
-
-            static __device__ __forceinline__  uchar1 operator+(const uchar1& a, const uchar1& b)
-            {
-                return make_uchar1(a.x + b.x);
-            }
-            static __device__ __forceinline__  uchar1 operator-(const uchar1& a, const uchar1& b)
-            {
-                return make_uchar1(a.x - b.x);
-            }
-            static __device__ __forceinline__  uchar1 operator*(const uchar1& a, const uchar1& b)
-            {
-                return make_uchar1(a.x * b.x);
-            }
-            static __device__ __forceinline__  uchar1 operator/(const uchar1& a, const uchar1& b)
-            {
-                return make_uchar1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const uchar1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  uchar2 operator+(const uchar2& a, const uchar2& b)
-            {
-                return make_uchar2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  uchar2 operator-(const uchar2& a, const uchar2& b)
-            {
-                return make_uchar2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  uchar2 operator*(const uchar2& a, const uchar2& b)
-            {
-                return make_uchar2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  uchar2 operator/(const uchar2& a, const uchar2& b)
-            {
-                return make_uchar2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const uchar2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  uchar3 operator+(const uchar3& a, const uchar3& b)
-            {
-                return make_uchar3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  uchar3 operator-(const uchar3& a, const uchar3& b)
-            {
-                return make_uchar3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  uchar3 operator*(const uchar3& a, const uchar3& b)
-            {
-                return make_uchar3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  uchar3 operator/(const uchar3& a, const uchar3& b)
-            {
-                return make_uchar3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const uchar3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  uchar4 operator+(const uchar4& a, const uchar4& b)
-            {
-                return make_uchar4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  uchar4 operator-(const uchar4& a, const uchar4& b)
-            {
-                return make_uchar4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  uchar4 operator*(const uchar4& a, const uchar4& b)
-            {
-                return make_uchar4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  uchar4 operator/(const uchar4& a, const uchar4& b)
-            {
-                return make_uchar4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const uchar4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-            static __device__ __forceinline__  char1 operator+(const char1& a, const char1& b)
-            {
-                return make_char1(a.x + b.x);
-            }
-            static __device__ __forceinline__  char1 operator-(const char1& a, const char1& b)
-            {
-                return make_char1(a.x - b.x);
-            }
-            static __device__ __forceinline__  char1 operator*(const char1& a, const char1& b)
-            {
-                return make_char1(a.x * b.x);
-            }
-            static __device__ __forceinline__  char1 operator/(const char1& a, const char1& b)
-            {
-                return make_char1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const char1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  char2 operator+(const char2& a, const char2& b)
-            {
-                return make_char2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  char2 operator-(const char2& a, const char2& b)
-            {
-                return make_char2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  char2 operator*(const char2& a, const char2& b)
-            {
-                return make_char2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  char2 operator/(const char2& a, const char2& b)
-            {
-                return make_char2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const char2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  char3 operator+(const char3& a, const char3& b)
-            {
-                return make_char3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  char3 operator-(const char3& a, const char3& b)
-            {
-                return make_char3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  char3 operator*(const char3& a, const char3& b)
-            {
-                return make_char3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  char3 operator/(const char3& a, const char3& b)
-            {
-                return make_char3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const char3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  char4 operator+(const char4& a, const char4& b)
-            {
-                return make_char4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  char4 operator-(const char4& a, const char4& b)
-            {
-                return make_char4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  char4 operator*(const char4& a, const char4& b)
-            {
-                return make_char4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  char4 operator/(const char4& a, const char4& b)
-            {
-                return make_char4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const char4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-            static __device__ __forceinline__  ushort1 operator+(const ushort1& a, const ushort1& b)
-            {
-                return make_ushort1(a.x + b.x);
-            }
-            static __device__ __forceinline__  ushort1 operator-(const ushort1& a, const ushort1& b)
-            {
-                return make_ushort1(a.x - b.x);
-            }
-            static __device__ __forceinline__  ushort1 operator*(const ushort1& a, const ushort1& b)
-            {
-                return make_ushort1(a.x * b.x);
-            }
-            static __device__ __forceinline__  ushort1 operator/(const ushort1& a, const ushort1& b)
-            {
-                return make_ushort1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const ushort1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  ushort2 operator+(const ushort2& a, const ushort2& b)
-            {
-                return make_ushort2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  ushort2 operator-(const ushort2& a, const ushort2& b)
-            {
-                return make_ushort2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  ushort2 operator*(const ushort2& a, const ushort2& b)
-            {
-                return make_ushort2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  ushort2 operator/(const ushort2& a, const ushort2& b)
-            {
-                return make_ushort2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const ushort2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  ushort3 operator+(const ushort3& a, const ushort3& b)
-            {
-                return make_ushort3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  ushort3 operator-(const ushort3& a, const ushort3& b)
-            {
-                return make_ushort3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  ushort3 operator*(const ushort3& a, const ushort3& b)
-            {
-                return make_ushort3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  ushort3 operator/(const ushort3& a, const ushort3& b)
-            {
-                return make_ushort3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const ushort3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  ushort4 operator+(const ushort4& a, const ushort4& b)
-            {
-                return make_ushort4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  ushort4 operator-(const ushort4& a, const ushort4& b)
-            {
-                return make_ushort4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  ushort4 operator*(const ushort4& a, const ushort4& b)
-            {
-                return make_ushort4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  ushort4 operator/(const ushort4& a, const ushort4& b)
-            {
-                return make_ushort4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const ushort4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-            static __device__ __forceinline__  short1 operator+(const short1& a, const short1& b)
-            {
-                return make_short1(a.x + b.x);
-            }
-            static __device__ __forceinline__  short1 operator-(const short1& a, const short1& b)
-            {
-                return make_short1(a.x - b.x);
-            }
-            static __device__ __forceinline__  short1 operator*(const short1& a, const short1& b)
-            {
-                return make_short1(a.x * b.x);
-            }
-            static __device__ __forceinline__  short1 operator/(const short1& a, const short1& b)
-            {
-                return make_short1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const short1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  short2 operator+(const short2& a, const short2& b)
-            {
-                return make_short2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  short2 operator-(const short2& a, const short2& b)
-            {
-                return make_short2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  short2 operator*(const short2& a, const short2& b)
-            {
-                return make_short2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  short2 operator/(const short2& a, const short2& b)
-            {
-                return make_short2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const short2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  short3 operator+(const short3& a, const short3& b)
-            {
-                return make_short3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  short3 operator-(const short3& a, const short3& b)
-            {
-                return make_short3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  short3 operator*(const short3& a, const short3& b)
-            {
-                return make_short3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  short3 operator/(const short3& a, const short3& b)
-            {
-                return make_short3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const short3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  short4 operator+(const short4& a, const short4& b)
-            {
-                return make_short4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  short4 operator-(const short4& a, const short4& b)
-            {
-                return make_short4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  short4 operator*(const short4& a, const short4& b)
-            {
-                return make_short4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  short4 operator/(const short4& a, const short4& b)
-            {
-                return make_short4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const short4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-            static __device__ __forceinline__  int1 operator+(const int1& a, const int1& b)
-            {
-                return make_int1(a.x + b.x);
-            }
-            static __device__ __forceinline__  int1 operator-(const int1& a, const int1& b)
-            {
-                return make_int1(a.x - b.x);
-            }
-            static __device__ __forceinline__  int1 operator*(const int1& a, const int1& b)
-            {
-                return make_int1(a.x * b.x);
-            }
-            static __device__ __forceinline__  int1 operator/(const int1& a, const int1& b)
-            {
-                return make_int1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const int1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  int2 operator+(const int2& a, const int2& b)
-            {
-                return make_int2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  int2 operator-(const int2& a, const int2& b)
-            {
-                return make_int2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  int2 operator*(const int2& a, const int2& b)
-            {
-                return make_int2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  int2 operator/(const int2& a, const int2& b)
-            {
-                return make_int2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const int2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  int3 operator+(const int3& a, const int3& b)
-            {
-                return make_int3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  int3 operator-(const int3& a, const int3& b)
-            {
-                return make_int3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  int3 operator*(const int3& a, const int3& b)
-            {
-                return make_int3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  int3 operator/(const int3& a, const int3& b)
-            {
-                return make_int3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const int3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  int4 operator+(const int4& a, const int4& b)
-            {
-                return make_int4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  int4 operator-(const int4& a, const int4& b)
-            {
-                return make_int4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  int4 operator*(const int4& a, const int4& b)
-            {
-                return make_int4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  int4 operator/(const int4& a, const int4& b)
-            {
-                return make_int4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const int4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-
-            static __device__ __forceinline__  uint1 operator+(const uint1& a, const uint1& b)
-            {
-                return make_uint1(a.x + b.x);
-            }
-            static __device__ __forceinline__  uint1 operator-(const uint1& a, const uint1& b)
-            {
-                return make_uint1(a.x - b.x);
-            }
-            static __device__ __forceinline__  uint1 operator*(const uint1& a, const uint1& b)
-            {
-                return make_uint1(a.x * b.x);
-            }
-            static __device__ __forceinline__  uint1 operator/(const uint1& a, const uint1& b)
-            {
-                return make_uint1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const uint1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  uint2 operator+(const uint2& a, const uint2& b)
-            {
-                return make_uint2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  uint2 operator-(const uint2& a, const uint2& b)
-            {
-                return make_uint2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  uint2 operator*(const uint2& a, const uint2& b)
-            {
-                return make_uint2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  uint2 operator/(const uint2& a, const uint2& b)
-            {
-                return make_uint2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const uint2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  uint3 operator+(const uint3& a, const uint3& b)
-            {
-                return make_uint3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  uint3 operator-(const uint3& a, const uint3& b)
-            {
-                return make_uint3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  uint3 operator*(const uint3& a, const uint3& b)
-            {
-                return make_uint3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  uint3 operator/(const uint3& a, const uint3& b)
-            {
-                return make_uint3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const uint3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  uint4 operator+(const uint4& a, const uint4& b)
-            {
-                return make_uint4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  uint4 operator-(const uint4& a, const uint4& b)
-            {
-                return make_uint4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  uint4 operator*(const uint4& a, const uint4& b)
-            {
-                return make_uint4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  uint4 operator/(const uint4& a, const uint4& b)
-            {
-                return make_uint4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const uint4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-
-            static __device__ __forceinline__  float1 operator+(const float1& a, const float1& b)
-            {
-                return make_float1(a.x + b.x);
-            }
-            static __device__ __forceinline__  float1 operator-(const float1& a, const float1& b)
-            {
-                return make_float1(a.x - b.x);
-            }
-            static __device__ __forceinline__  float1 operator*(const float1& a, const float1& b)
-            {
-                return make_float1(a.x * b.x);
-            }
-            static __device__ __forceinline__  float1 operator/(const float1& a, const float1& b)
-            {
-                return make_float1(a.x / b.x);
-            }
-            static __device__ __forceinline__ float1 operator*(const float1& a, float s)
-            {
-                return make_float1(a.x * s);
-            }
-
-            static __device__ __forceinline__  float2 operator+(const float2& a, const float2& b)
-            {
-                return make_float2(a.x + b.x, a.y + b.y);
-            }
-            static __device__ __forceinline__  float2 operator-(const float2& a, const float2& b)
-            {
-                return make_float2(a.x - b.x, a.y - b.y);
-            }
-            static __device__ __forceinline__  float2 operator*(const float2& a, const float2& b)
-            {
-                return make_float2(a.x * b.x, a.y * b.y);
-            }
-            static __device__ __forceinline__  float2 operator/(const float2& a, const float2& b)
-            {
-                return make_float2(a.x / b.x, a.y / b.y);
-            }
-            static __device__ __forceinline__ float2 operator*(const float2& a, float s)
-            {
-                return make_float2(a.x * s, a.y * s);
-            }
-
-            static __device__ __forceinline__  float3 operator+(const float3& a, const float3& b)
-            {
-                return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
-            }
-            static __device__ __forceinline__  float3 operator-(const float3& a, const float3& b)
-            {
-                return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);
-            }
-            static __device__ __forceinline__  float3 operator*(const float3& a, const float3& b)
-            {
-                return make_float3(a.x * b.x, a.y * b.y, a.z * b.z);
-            }
-            static __device__ __forceinline__  float3 operator/(const float3& a, const float3& b)
-            {
-                return make_float3(a.x / b.x, a.y / b.y, a.z / b.z);
-            }
-            static __device__ __forceinline__ float3 operator*(const float3& a, float s)
-            {
-                return make_float3(a.x * s, a.y * s, a.z * s);
-            }
-
-            static __device__ __forceinline__  float4 operator+(const float4& a, const float4& b)
-            {
-                return make_float4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
-            }
-            static __device__ __forceinline__  float4 operator-(const float4& a, const float4& b)
-            {
-                return make_float4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
-            }
-            static __device__ __forceinline__  float4 operator*(const float4& a, const float4& b)
-            {
-                return make_float4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
-            }
-            static __device__ __forceinline__  float4 operator/(const float4& a, const float4& b)
-            {
-                return make_float4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
-            }
-            static __device__ __forceinline__ float4 operator*(const float4& a, float s)
-            {
-                return make_float4(a.x * s, a.y * s, a.z * s, a.w * s);
-            }
-        }            
-    }
-}
-
-#endif // __OPENCV_GPU_VECMATH_HPP__
\ No newline at end of file
diff --git a/modules/gpu/src/speckle_filtering.cpp b/modules/gpu/src/speckle_filtering.cpp
index 628e11b62d..f714314e58 100644
--- a/modules/gpu/src/speckle_filtering.cpp
+++ b/modules/gpu/src/speckle_filtering.cpp
@@ -64,10 +64,10 @@ void cv::filterSpeckles( Mat& img, uchar newVal, int maxSpeckleSize, uchar maxDi
     int width = img.cols, height = img.rows, npixels = width*height;
     size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar));
     if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
-        _buf.create(1, bufSize, CV_8U);
+        _buf.create(1, (int)bufSize, CV_8U);
 
     uchar* buf = _buf.data;
-    int i, j, dstep = img.step/sizeof(uchar);
+    int i, j, dstep = (int)(img.step/sizeof(uchar));
     int* labels = (int*)buf;
     buf += npixels*sizeof(labels[0]);
     Point2s* wbuf = (Point2s*)buf;
diff --git a/modules/gpu/src/split_merge.cpp b/modules/gpu/src/split_merge.cpp
index 3b3a3120b0..a8785d43ca 100644
--- a/modules/gpu/src/split_merge.cpp
+++ b/modules/gpu/src/split_merge.cpp
@@ -56,11 +56,11 @@ void cv::gpu::split(const GpuMat& /*src*/, vector<GpuMat>& /*dst*/, Stream& /*st
 namespace cv { namespace gpu { namespace split_merge 
 {    
     extern "C" void merge_caller(const DevMem2D* src, DevMem2D& dst, 
-                                 int total_channels, int elem_size, 
+                                 int total_channels, size_t elem_size, 
                                  const cudaStream_t& stream);
 
     extern "C" void split_caller(const DevMem2D& src, DevMem2D* dst, 
-                                 int num_channels, int elem_size1, 
+                                 int num_channels, size_t elem_size1, 
                                  const cudaStream_t& stream);
 
     void merge(const GpuMat* src, size_t n, GpuMat& dst, const cudaStream_t& stream) 
diff --git a/modules/gpu/src/stereocsbp.cpp b/modules/gpu/src/stereocsbp.cpp
index 25beb8b6ab..d026ebb47d 100644
--- a/modules/gpu/src/stereocsbp.cpp
+++ b/modules/gpu/src/stereocsbp.cpp
@@ -107,7 +107,7 @@ void cv::gpu::StereoConstantSpaceBP::estimateRecommendedParams(int width, int he
     levels = (int)::log(static_cast<double>(mm)) * 2 / 3;
     if (levels == 0) levels++;
 
-    nr_plane = (int) ((float) ndisp / pow(2.0, levels + 1));
+    nr_plane = (int) ((float) ndisp / std::pow(2.0, levels + 1));
 }
 
 cv::gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp_, int iters_, int levels_, int nr_plane_,
@@ -167,7 +167,7 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
     nr_plane_pyr[0] = rthis.nr_plane;
 
     const int n = 64;
-    step_pyr[0] = alignSize(cols * sizeof(T), n) / sizeof(T);
+    step_pyr[0] = static_cast<int>(alignSize(cols * sizeof(T), n) / sizeof(T));
     for (int i = 1; i < levels; i++)
     {
         cols_pyr[i] = (cols_pyr[i-1] + 1) / 2;
@@ -175,7 +175,7 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
 
         nr_plane_pyr[i] = nr_plane_pyr[i-1] * 2;
 
-        step_pyr[i] = alignSize(cols_pyr[i] * sizeof(T), n) / sizeof(T);
+        step_pyr[i] = static_cast<int>(alignSize(cols_pyr[i] * sizeof(T), n) / sizeof(T));
     }
 
     Size msg_size(step_pyr[0], rows * nr_plane_pyr[0]);
@@ -197,7 +197,7 @@ static void csbp_operator(StereoConstantSpaceBP& rthis, GpuMat u[2], GpuMat d[2]
     data_cost.create(data_cost_size, DataType<T>::type);
     data_cost_selected.create(msg_size, DataType<T>::type);
 
-    step_pyr[0] = data_cost.step / sizeof(T);
+    step_pyr[0] = static_cast<int>(data_cost.step / sizeof(T));
 
     Size temp_size = data_cost_size;
     if (data_cost_size.width * data_cost_size.height < step_pyr[levels - 1] * rows_pyr[levels - 1] * rthis.ndisp)
diff --git a/modules/gpu/src/surf.cpp b/modules/gpu/src/surf.cpp
index 2ec6b2992b..9a4e6ec91c 100644
--- a/modules/gpu/src/surf.cpp
+++ b/modules/gpu/src/surf.cpp
@@ -59,6 +59,7 @@ void cv::gpu::SURF_GPU::operator()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat
 void cv::gpu::SURF_GPU::operator()(const GpuMat&, const GpuMat&, vector<KeyPoint>&) { throw_nogpu(); }
 void cv::gpu::SURF_GPU::operator()(const GpuMat&, const GpuMat&, vector<KeyPoint>&, GpuMat&, bool) { throw_nogpu(); }
 void cv::gpu::SURF_GPU::operator()(const GpuMat&, const GpuMat&, vector<KeyPoint>&, vector<float>&, bool) { throw_nogpu(); }
+void cv::gpu::SURF_GPU::releaseMemory() { throw_nogpu(); }
 
 #else /* !defined (HAVE_CUDA) */
 
@@ -95,9 +96,7 @@ namespace
 
             img_cols(img.cols), img_rows(img.rows),
 
-            use_mask(!mask.empty()),
-
-            upright(surf.upright)
+            use_mask(!mask.empty())
         {
             CV_Assert(!img.empty() && img.type() == CV_8UC1);
             CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1));
@@ -108,9 +107,9 @@ namespace
             maxCandidates = min(static_cast<int>(1.5 * maxFeatures), 65535);
 
             CV_Assert(maxFeatures > 0);
-            
-            cudaSafeCall( cudaMalloc((void**)&d_counters, (nOctaves + 1) * sizeof(unsigned int)) );
-            cudaSafeCall( cudaMemset(d_counters, 0, (nOctaves + 1) * sizeof(unsigned int)) );
+
+            counters.create(1, nOctaves + 1, CV_32SC1);
+            counters.setTo(Scalar::all(0));
 
             uploadConstant("cv::gpu::surf::c_max_candidates",    maxCandidates);
             uploadConstant("cv::gpu::surf::c_max_features",      maxFeatures);
@@ -119,30 +118,20 @@ namespace
             uploadConstant("cv::gpu::surf::c_nOctaveLayers",     nOctaveLayers);
             uploadConstant("cv::gpu::surf::c_hessianThreshold",  static_cast<float>(hessianThreshold));
 
-            bindTexture("cv::gpu::surf::imgTex", (DevMem2D)img);
+            imgTex.bind("cv::gpu::surf::imgTex", (DevMem2D)img);
 
             integralBuffered(img, sum, intBuffer);
-            bindTexture("cv::gpu::surf::sumTex", (DevMem2D_<unsigned int>)sum);
+            sumTex.bind("cv::gpu::surf::sumTex", (DevMem2D_<unsigned int>)sum);
 
             if (use_mask)
             {
                 min(mask, 1.0, mask1);
                 integralBuffered(mask1, maskSum, intBuffer);
 
-                bindTexture("cv::gpu::surf::maskSumTex", (DevMem2D_<unsigned int>)maskSum);
+                maskSumTex.bind("cv::gpu::surf::maskSumTex", (DevMem2D_<unsigned int>)maskSum);
             }
         }
 
-        ~SURF_GPU_Invoker()
-        {
-            cudaSafeCall( cudaFree(d_counters) );
-
-            unbindTexture("cv::gpu::surf::imgTex");
-            unbindTexture("cv::gpu::surf::sumTex");
-            if (use_mask)
-                unbindTexture("cv::gpu::surf::maskSumTex");
-        }
-
         void detectKeypoints(GpuMat& keypoints)
         {
             ensureSizeIsEnough(img_rows * (nOctaveLayers + 2), img_cols, CV_32FC1, det);
@@ -163,11 +152,11 @@ namespace
 
                 icvCalcLayerDetAndTrace_gpu(det, trace, img_rows, img_cols, octave, nOctaveLayers);
 
-                icvFindMaximaInLayer_gpu(det, trace, maxPosBuffer.ptr<int4>(), d_counters + 1 + octave,
+                icvFindMaximaInLayer_gpu(det, trace, maxPosBuffer.ptr<int4>(), counters.ptr<unsigned int>() + 1 + octave,
                     img_rows, img_cols, octave, use_mask, nOctaveLayers);
 
                 unsigned int maxCounter;
-                cudaSafeCall( cudaMemcpy(&maxCounter, d_counters + 1 + octave, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+                cudaSafeCall( cudaMemcpy(&maxCounter, counters.ptr<unsigned int>() + 1 + octave, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
                 maxCounter = std::min(maxCounter, static_cast<unsigned int>(maxCandidates));
 
                 if (maxCounter > 0)
@@ -175,11 +164,11 @@ namespace
                     icvInterpolateKeypoint_gpu(det, maxPosBuffer.ptr<int4>(), maxCounter, 
                         keypoints.ptr<float>(SURF_GPU::SF_X), keypoints.ptr<float>(SURF_GPU::SF_Y),
                         keypoints.ptr<int>(SURF_GPU::SF_LAPLACIAN), keypoints.ptr<float>(SURF_GPU::SF_SIZE),
-                        keypoints.ptr<float>(SURF_GPU::SF_HESSIAN), d_counters);
+                        keypoints.ptr<float>(SURF_GPU::SF_HESSIAN), counters.ptr<unsigned int>());
                 }
             }
             unsigned int featureCounter;
-            cudaSafeCall( cudaMemcpy(&featureCounter, d_counters, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+            cudaSafeCall( cudaMemcpy(&featureCounter, counters.ptr<unsigned int>(), sizeof(unsigned int), cudaMemcpyDeviceToHost) );
             featureCounter = std::min(featureCounter, static_cast<unsigned int>(maxFeatures));
 
             keypoints.cols = featureCounter;
@@ -203,7 +192,7 @@ namespace
             const int nFeatures = keypoints.cols;
             if (nFeatures > 0)
             {
-                descriptors.create(nFeatures, descriptorSize, CV_32F);
+                ensureSizeIsEnough(nFeatures, descriptorSize, CV_32F, descriptors);
                 compute_descriptors_gpu(descriptors, keypoints.ptr<float>(SURF_GPU::SF_X), keypoints.ptr<float>(SURF_GPU::SF_Y),
                     keypoints.ptr<float>(SURF_GPU::SF_SIZE), keypoints.ptr<float>(SURF_GPU::SF_DIR), nFeatures);
             }
@@ -224,12 +213,12 @@ namespace
 
         bool use_mask;
 
-        bool upright;
-
         int maxCandidates;
         int maxFeatures;
 
-        unsigned int* d_counters;
+        GpuMat counters;
+
+        TextureBinder imgTex, sumTex, maskSumTex;
     };
 }
 
@@ -264,7 +253,7 @@ void cv::gpu::SURF_GPU::uploadKeypoints(const vector<KeyPoint>& keypoints, GpuMa
         keypointsGPU.release();
     else
     {
-        Mat keypointsCPU(SURF_GPU::SF_FEATURE_STRIDE, keypoints.size(), CV_32FC1);
+        Mat keypointsCPU(SURF_GPU::SF_FEATURE_STRIDE, static_cast<int>(keypoints.size()), CV_32FC1);
 
         float* kp_x = keypointsCPU.ptr<float>(SURF_GPU::SF_X);
         float* kp_y = keypointsCPU.ptr<float>(SURF_GPU::SF_Y);
@@ -435,4 +424,15 @@ void cv::gpu::SURF_GPU::operator()(const GpuMat& img, const GpuMat& mask, vector
     downloadDescriptors(descriptorsGPU, descriptors);
 }
 
+void cv::gpu::SURF_GPU::releaseMemory() 
+{
+    sum.release(); 
+    mask1.release();
+    maskSum.release();
+    intBuffer.release();
+    det.release();
+    trace.release();
+    maxPosBuffer.release();
+}
+
 #endif /* !defined (HAVE_CUDA) */
diff --git a/modules/gpu/test/nvidia/NCVAutoTestLister.hpp b/modules/gpu/test/nvidia/NCVAutoTestLister.hpp
index d8106efc74..bdaa8fac67 100644
--- a/modules/gpu/test/nvidia/NCVAutoTestLister.hpp
+++ b/modules/gpu/test/nvidia/NCVAutoTestLister.hpp
@@ -15,15 +15,22 @@
 
 #include "NCVTest.hpp"
 
+enum OutputLevel
+{
+    OutputLevelNone,
+    OutputLevelCompact,
+    OutputLevelFull
+};
+
 class NCVAutoTestLister
 {
 public:
 
-    NCVAutoTestLister(std::string testSuiteName, NcvBool bStopOnFirstFail=false, NcvBool bCompactOutput=true)
+    NCVAutoTestLister(std::string testSuiteName, OutputLevel outputLevel = OutputLevelCompact, NcvBool bStopOnFirstFail=false)
         :
     testSuiteName(testSuiteName),
-    bStopOnFirstFail(bStopOnFirstFail),
-    bCompactOutput(bCompactOutput)
+    outputLevel(outputLevel),
+    bStopOnFirstFail(bStopOnFirstFail)
     {
     }
 
@@ -38,7 +45,7 @@ public:
         Ncv32u nFailed = 0;
         Ncv32u nFailedMem = 0;
 
-        if (bCompactOutput)
+        if (outputLevel == OutputLevelCompact)
         {
             printf("Test suite '%s' with %d tests\n", 
                 testSuiteName.c_str(),
@@ -52,7 +59,7 @@ public:
             NCVTestReport curReport;
             bool res = curTest.executeTest(curReport);
 
-            if (!bCompactOutput)
+            if (outputLevel == OutputLevelFull)
             {
                 printf("Test %3i %16s; Consumed mem GPU = %8d, CPU = %8d; %s\n",
                     i,
@@ -65,7 +72,7 @@ public:
             if (res)
             {
                 nPassed++;
-                if (bCompactOutput)
+                if (outputLevel == OutputLevelCompact)
                 {
                     printf(".");
                 }
@@ -75,7 +82,7 @@ public:
                 if (!curReport.statsText["rcode"].compare("FAILED"))
                 {
                     nFailed++;
-                    if (bCompactOutput)
+                    if (outputLevel == OutputLevelCompact)
                     {
                         printf("x");
                     }
@@ -87,7 +94,7 @@ public:
                 else
                 {
                     nFailedMem++;
-                    if (bCompactOutput)
+                    if (outputLevel == OutputLevelCompact)
                     {
                         printf("m");
                     }
@@ -95,17 +102,20 @@ public:
             }
             fflush(stdout);
         }
-        if (bCompactOutput)
+        if (outputLevel == OutputLevelCompact)
         {
             printf("\n");
         }
 
-        printf("Test suite '%s' complete: %d total, %d passed, %d memory errors, %d failed\n\n", 
-            testSuiteName.c_str(),
-            (int)(this->tests.size()),
-            nPassed,
-            nFailedMem,
-            nFailed);
+        if (outputLevel != OutputLevelNone)
+        {
+            printf("Test suite '%s' complete: %d total, %d passed, %d memory errors, %d failed\n\n", 
+                testSuiteName.c_str(),
+                (int)(this->tests.size()),
+                nPassed,
+                nFailedMem,
+                nFailed);
+        }
 
         bool passed = nFailed == 0 && nFailedMem == 0;
         return passed;
@@ -121,9 +131,9 @@ public:
 
 private:
 
-    NcvBool bStopOnFirstFail;
-    NcvBool bCompactOutput;
     std::string testSuiteName;
+    OutputLevel outputLevel;
+    NcvBool bStopOnFirstFail;
     std::vector<INCVTest *> tests;
 };
 
diff --git a/modules/gpu/test/nvidia/NCVTest.hpp b/modules/gpu/test/nvidia/NCVTest.hpp
index b8c2d9729e..00be0f0d19 100644
--- a/modules/gpu/test/nvidia/NCVTest.hpp
+++ b/modules/gpu/test/nvidia/NCVTest.hpp
@@ -124,8 +124,8 @@ private:
 
     bool initMemory(NCVTestReport &report)
     {
-        this->allocatorGPU.reset(new NCVMemStackAllocator(devProp.textureAlignment));
-        this->allocatorCPU.reset(new NCVMemStackAllocator(devProp.textureAlignment));
+        this->allocatorGPU.reset(new NCVMemStackAllocator(static_cast<Ncv32u>(devProp.textureAlignment)));
+        this->allocatorCPU.reset(new NCVMemStackAllocator(static_cast<Ncv32u>(devProp.textureAlignment)));
 
         if (!this->allocatorGPU.get()->isInitialized() ||
             !this->allocatorCPU.get()->isInitialized())
@@ -146,9 +146,9 @@ private:
         report.statsNums["MemGPU"] = maxGPUsize;
         report.statsNums["MemCPU"] = maxCPUsize;
 
-        this->allocatorGPU.reset(new NCVMemStackAllocator(NCVMemoryTypeDevice, maxGPUsize, devProp.textureAlignment));
+        this->allocatorGPU.reset(new NCVMemStackAllocator(NCVMemoryTypeDevice, maxGPUsize, static_cast<Ncv32u>(devProp.textureAlignment)));
 
-        this->allocatorCPU.reset(new NCVMemStackAllocator(NCVMemoryTypeHostPinned, maxCPUsize, devProp.textureAlignment));
+        this->allocatorCPU.reset(new NCVMemStackAllocator(NCVMemoryTypeHostPinned, maxCPUsize, static_cast<Ncv32u>(devProp.textureAlignment)));
 
         if (!this->allocatorGPU.get()->isInitialized() ||
             !this->allocatorCPU.get()->isInitialized())
diff --git a/modules/gpu/test/nvidia/NCVTestSourceProvider.hpp b/modules/gpu/test/nvidia/NCVTestSourceProvider.hpp
index f4f9a392ec..99ea6682b1 100644
--- a/modules/gpu/test/nvidia/NCVTestSourceProvider.hpp
+++ b/modules/gpu/test/nvidia/NCVTestSourceProvider.hpp
@@ -35,7 +35,7 @@ public:
 
         //Ncv32u maxWpitch = alignUp(maxWidth * sizeof(T), devProp.textureAlignment);
 
-        allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, devProp.textureAlignment));
+        allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, static_cast<Ncv32u>(devProp.textureAlignment)));
         data.reset(new NCVMatrixAlloc<T>(*this->allocatorCPU.get(), maxWidth, maxHeight));
         ncvAssertPrintReturn(data.get()->isMemAllocated(), "NCVTestSourceProvider ctor:: Matrix not allocated", );
 
@@ -70,7 +70,7 @@ public:
         ncvAssertPrintReturn(cudaSuccess == cudaGetDevice(&devId), "Error returned from cudaGetDevice", );
         ncvAssertPrintReturn(cudaSuccess == cudaGetDeviceProperties(&devProp, devId), "Error returned from cudaGetDeviceProperties", );
 
-        allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, devProp.textureAlignment));
+        allocatorCPU.reset(new NCVMemNativeAllocator(NCVMemoryTypeHostPinned, static_cast<Ncv32u>(devProp.textureAlignment)));
         data.reset(new NCVMatrixAlloc<T>(*this->allocatorCPU.get(), image.cols, image.rows));
         ncvAssertPrintReturn(data.get()->isMemAllocated(), "NCVTestSourceProvider ctor:: Matrix not allocated", );
 
diff --git a/modules/gpu/test/nvidia/TestHypothesesFilter.cpp b/modules/gpu/test/nvidia/TestHypothesesFilter.cpp
index c75890d229..4785abae41 100644
--- a/modules/gpu/test/nvidia/TestHypothesesFilter.cpp
+++ b/modules/gpu/test/nvidia/TestHypothesesFilter.cpp
@@ -132,7 +132,7 @@ bool TestHypothesesFilter::process()
     }
     NCV_SKIP_COND_END
 
-    Ncv32u numHypothesesSrc = h_vecSrc.length();
+    Ncv32u numHypothesesSrc = static_cast<Ncv32u>(h_vecSrc.length());
     NCV_SKIP_COND_BEGIN
     ncvStat = ncvGroupRectangles_host(h_vecSrc, numHypothesesSrc, this->minNeighbors, this->eps, NULL);
     ncvAssertReturn(ncvStat == NCV_SUCCESS, false);
diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp
index 31f0cb1121..994737eee4 100644
--- a/modules/gpu/test/nvidia/main_nvidia.cpp
+++ b/modules/gpu/test/nvidia/main_nvidia.cpp
@@ -288,70 +288,162 @@ static void devNullOutput(const char *msg)
 
 }
 
-
-bool main_nvidia(const std::string& test_data_path)
+bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
 	path = test_data_path;
-
-    printf("Testing NVIDIA Computer Vision SDK\n");
-    printf("==================================\n");
-
     ncvSetDebugOutputHandler(devNullOutput);
 
-    NCVAutoTestLister testListerII("NPPST Integral Image"                   );//,,true, false);
-    NCVAutoTestLister testListerSII("NPPST Squared Integral Image"          );//,,true, false);
-    NCVAutoTestLister testListerRStdDev("NPPST RectStdDev"                  );//,,true, false);
-    NCVAutoTestLister testListerResize("NPPST Resize"                       );//,,true, false);
-    NCVAutoTestLister testListerNPPSTVectorOperations("NPPST Vector Operations"  );//,,true, false);
-    NCVAutoTestLister testListerTranspose("NPPST Transpose"                 );//,,true, false);
-
-    NCVAutoTestLister testListerVectorOperations("Vector Operations"        );//,,true, false);
-    NCVAutoTestLister testListerHaarLoader("Haar Cascade Loader"            );//,,true, false);
-    NCVAutoTestLister testListerHaarAppl("Haar Cascade Application"         );//,,true, false);
-    NCVAutoTestLister testListerHypFiltration("Hypotheses Filtration"       );//,,true, false);
-    NCVAutoTestLister testListerVisualize("Visualization"                   );//,,true, false);
-
-    printf("Initializing data source providers\n");
-    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+    NCVAutoTestLister testListerII("NPPST Integral Image", outputLevel);
+    
     NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 4096, 4096);
-    NCVTestSourceProvider<Ncv64u> testSrcRandom_64u(2010, 0, -1, 4096, 4096);
-    NCVTestSourceProvider<Ncv8u> testSrcFacesVGA_8u(path + "group_1_640x480_VGA.pgm");
     NCVTestSourceProvider<Ncv32f> testSrcRandom_32f(2010, -1.0f, 1.0f, 4096, 4096);
 
-    printf("Generating NPPST test suites\n");
     generateIntegralTests<Ncv8u, Ncv32u>(testListerII, testSrcRandom_8u, 4096, 4096);
     generateIntegralTests<Ncv32f, Ncv32f>(testListerII, testSrcRandom_32f, 4096, 4096);
+
+    return testListerII.invoke();
+}
+
+bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+
+    NCVAutoTestLister testListerSII("NPPST Squared Integral Image", outputLevel);
+
+    NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 4096, 4096);
+
     generateSquaredIntegralTests(testListerSII, testSrcRandom_8u, 4096, 4096);
+
+    return testListerSII.invoke();
+}
+
+bool nvidia_NPPST_RectStdDev(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+    
+    NCVAutoTestLister testListerRStdDev("NPPST RectStdDev", outputLevel);
+    
+    NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 4096, 4096);
+
     generateRectStdDevTests(testListerRStdDev, testSrcRandom_8u, 4096, 4096);
+
+    return testListerRStdDev.invoke();
+}
+
+bool nvidia_NPPST_Resize(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+
+    NCVAutoTestLister testListerResize("NPPST Resize", outputLevel);
+
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+    NCVTestSourceProvider<Ncv64u> testSrcRandom_64u(2010, 0, -1, 4096, 4096);
+
     generateResizeTests(testListerResize, testSrcRandom_32u);
     generateResizeTests(testListerResize, testSrcRandom_64u);
+
+    return testListerResize.invoke();
+}
+
+bool nvidia_NPPST_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+    
+    NCVAutoTestLister testListerNPPSTVectorOperations("NPPST Vector Operations", outputLevel);
+    
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+
     generateNPPSTVectorTests(testListerNPPSTVectorOperations, testSrcRandom_32u, 4096*4096);
+
+    return testListerNPPSTVectorOperations.invoke();
+}
+
+bool nvidia_NPPST_Transpose(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+
+    NCVAutoTestLister testListerTranspose("NPPST Transpose", outputLevel);
+    
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+    NCVTestSourceProvider<Ncv64u> testSrcRandom_64u(2010, 0, -1, 4096, 4096);
+
     generateTransposeTests(testListerTranspose, testSrcRandom_32u);
     generateTransposeTests(testListerTranspose, testSrcRandom_64u);
 
-    printf("Generating NCV test suites\n");
-    generateDrawRectsTests(testListerVisualize, testSrcRandom_8u, testSrcRandom_32u, 4096, 4096);
-    generateDrawRectsTests(testListerVisualize, testSrcRandom_32u, testSrcRandom_32u, 4096, 4096);
+    return testListerTranspose.invoke();
+}
+
+bool nvidia_NCV_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+    
+    NCVAutoTestLister testListerVectorOperations("Vector Operations", outputLevel);
+
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+    
     generateVectorTests(testListerVectorOperations, testSrcRandom_32u, 4096*4096);
-    generateHypothesesFiltrationTests(testListerHypFiltration, testSrcRandom_32u, 1024);
+
+    return testListerVectorOperations.invoke();
+}
+
+bool nvidia_NCV_Haar_Cascade_Loader(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+
+    NCVAutoTestLister testListerHaarLoader("Haar Cascade Loader", outputLevel);
+    
     generateHaarLoaderTests(testListerHaarLoader);
+
+    return testListerHaarLoader.invoke();
+}
+
+bool nvidia_NCV_Haar_Cascade_Application(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+    
+    NCVAutoTestLister testListerHaarAppl("Haar Cascade Application", outputLevel);
+    
+    NCVTestSourceProvider<Ncv8u> testSrcFacesVGA_8u(path + "group_1_640x480_VGA.pgm");
+    
     generateHaarApplicationTests(testListerHaarAppl, testSrcFacesVGA_8u, 1280, 720);
 
-    // Indicate if at least one test failed
-    bool passed = true;
-
-    // Invoke all tests
-    passed &= testListerII.invoke();
-    passed &= testListerSII.invoke();
-    passed &= testListerRStdDev.invoke();
-    passed &= testListerResize.invoke();
-    passed &= testListerNPPSTVectorOperations.invoke();
-    passed &= testListerTranspose.invoke();
-    passed &= testListerVisualize.invoke();
-    passed &= testListerVectorOperations.invoke();
-    passed &= testListerHypFiltration.invoke();
-    passed &= testListerHaarLoader.invoke();
-    passed &= testListerHaarAppl.invoke();
-
-    return passed;
+    return testListerHaarAppl.invoke();
+}
+
+bool nvidia_NCV_Hypotheses_Filtration(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+    
+    NCVAutoTestLister testListerHypFiltration("Hypotheses Filtration", outputLevel);
+    
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+
+    generateHypothesesFiltrationTests(testListerHypFiltration, testSrcRandom_32u, 1024);
+
+    return testListerHypFiltration.invoke();
+}
+
+bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel outputLevel)
+{
+	path = test_data_path;
+    ncvSetDebugOutputHandler(devNullOutput);
+
+    NCVAutoTestLister testListerVisualize("Visualization", outputLevel);
+
+    NCVTestSourceProvider<Ncv8u> testSrcRandom_8u(2010, 0, 255, 4096, 4096);
+    NCVTestSourceProvider<Ncv32u> testSrcRandom_32u(2010, 0, 0xFFFFFFFF, 4096, 4096);
+    
+    generateDrawRectsTests(testListerVisualize, testSrcRandom_8u, testSrcRandom_32u, 4096, 4096);
+    generateDrawRectsTests(testListerVisualize, testSrcRandom_32u, testSrcRandom_32u, 4096, 4096);
+
+    return testListerVisualize.invoke();
 }
diff --git a/modules/gpu/test/test_arithm.cpp b/modules/gpu/test/test_arithm.cpp
index 7e72b24afe..a8fcccdcab 100644
--- a/modules/gpu/test/test_arithm.cpp
+++ b/modules/gpu/test/test_arithm.cpp
@@ -39,1026 +39,1677 @@
 //
 //M*/
 
-#include <iostream>
-#include <cmath>
-#include <limits>
 #include "test_precomp.hpp"
 
-using namespace cv;
-using namespace std;
-using namespace gpu;
+#ifdef HAVE_CUDA
 
-#define CHECK(pred, err) if (!(pred)) { \
-    ts->printf(cvtest::TS::CONSOLE, "Fail: \"%s\" at line: %d\n", #pred, __LINE__); \
-    ts->set_failed_test_info(err); \
-    return; }
-
-class CV_GpuArithmTest : public cvtest::BaseTest
+struct ArithmTest : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
 {
-public:
-    CV_GpuArithmTest(const char* /*test_name*/, const char* /*test_funcs*/){}
-    virtual ~CV_GpuArithmTest() {}
+    cv::gpu::DeviceInfo devInfo;
+    int type;
 
-protected:
-    void run(int);
+    cv::Size size;
+    cv::Mat mat1, mat2;
+        
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
 
-    int test(int type);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-    virtual int test(const Mat& mat1, const Mat& mat2) = 0;
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-    int CheckNorm(const Mat& m1, const Mat& m2, double eps = 1e-5);
-    int CheckNorm(const Scalar& s1, const Scalar& s2, double eps = 1e-5);
-    int CheckNorm(double d1, double d2, double eps = 1e-5);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat1 = cvtest::randomMat(rng, size, type, 1, 16, false);
+        mat2 = cvtest::randomMat(rng, size, type, 1, 16, false);
+    }
 };
 
-int CV_GpuArithmTest::test(int type)
+////////////////////////////////////////////////////////////////////////////////
+// add
+
+struct AddArray : ArithmTest {};
+
+TEST_P(AddArray, Accuracy) 
 {
-    cv::Size sz(200, 200);
-    cv::Mat mat1(sz, type), mat2(sz, type);
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
     
-    cv::RNG& rng = ts->get_rng();
+    cv::Mat dst_gold;
+    cv::add(mat1, mat2, dst_gold);
 
-    if (type != CV_32FC1)
-    {
-        rng.fill(mat1, cv::RNG::UNIFORM, cv::Scalar::all(1), cv::Scalar::all(20));
-        rng.fill(mat2, cv::RNG::UNIFORM, cv::Scalar::all(1), cv::Scalar::all(20));
-    }
-    else
-    {
-        rng.fill(mat1, cv::RNG::UNIFORM, cv::Scalar::all(0.1), cv::Scalar::all(1.0));
-        rng.fill(mat2, cv::RNG::UNIFORM, cv::Scalar::all(0.1), cv::Scalar::all(1.0));
-    }
+    cv::Mat dst;
 
-    return test(mat1, mat2);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::add(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-int CV_GpuArithmTest::CheckNorm(const Mat& m1, const Mat& m2, double eps)
+INSTANTIATE_TEST_CASE_P(Arithm, AddArray, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1)));
+
+struct AddScalar : ArithmTest {};
+
+TEST_P(AddScalar, Accuracy) 
 {
-    double ret = norm(m1, m2, NORM_INF);
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
 
-    if (ret < eps)
-        return cvtest::TS::OK;
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-    ts->printf(cvtest::TS::LOG, "\nNorm: %f\n", ret);
-    return cvtest::TS::FAIL_GENERIC;
+    cv::Scalar val(rng.uniform(0.1, 3.0), rng.uniform(0.1, 3.0));
+
+    PRINT_PARAM(val);
+    
+    cv::Mat dst_gold;
+    cv::add(mat1, val, dst_gold);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::add(cv::gpu::GpuMat(mat1), val, gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-int CV_GpuArithmTest::CheckNorm(const Scalar& s1, const Scalar& s2, double eps)
-{
-    int ret0 = CheckNorm(s1[0], s2[0], eps), 
-        ret1 = CheckNorm(s1[1], s2[1], eps), 
-        ret2 = CheckNorm(s1[2], s2[2], eps), 
-        ret3 = CheckNorm(s1[3], s2[3], eps);
-
-    return (ret0 == cvtest::TS::OK && ret1 == cvtest::TS::OK && ret2 == cvtest::TS::OK && ret3 == cvtest::TS::OK) ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC;
-}
-
-int CV_GpuArithmTest::CheckNorm(double d1, double d2, double eps)
-{
-    double ret = ::fabs(d1 - d2);
-
-    if (ret < eps)
-        return cvtest::TS::OK;
-
-    ts->printf(cvtest::TS::LOG, "\nNorm: %f\n", ret);
-    return cvtest::TS::FAIL_GENERIC;
-}
-
-void CV_GpuArithmTest::run( int )
-{
-    int testResult = cvtest::TS::OK;
-
-    const int types[] = {CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1};
-    const char* type_names[] = {"CV_8UC1 ", "CV_8UC3 ", "CV_8UC4 ", "CV_32FC1"};
-    const int type_count = sizeof(types)/sizeof(types[0]);
-
-    //run tests
-    for (int t = 0; t < type_count; ++t)
-    {
-        ts->printf(cvtest::TS::LOG, "Start testing %s", type_names[t]);
-
-        if (cvtest::TS::OK == test(types[t]))
-            ts->printf(cvtest::TS::LOG, "SUCCESS\n");
-        else
-        {
-            ts->printf(cvtest::TS::LOG, "FAIL\n");
-            testResult = cvtest::TS::FAIL_MISMATCH;
-        }
-    }
-
-    ts->set_failed_test_info(testResult);
-}
+INSTANTIATE_TEST_CASE_P(Arithm, AddScalar, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32FC1, CV_32FC2)));
 
 ////////////////////////////////////////////////////////////////////////////////
-// Add
+// subtract
 
-struct CV_GpuNppImageAddTest : public CV_GpuArithmTest
+struct SubtractArray : ArithmTest {};
+
+TEST_P(SubtractArray, Accuracy) 
 {
-    CV_GpuNppImageAddTest() : CV_GpuArithmTest( "GPU-NppImageAdd", "add" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    
+    cv::Mat dst_gold;
+    cv::subtract(mat1, mat2, dst_gold);
 
-        virtual int test(const Mat& mat1, const Mat& mat2)
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::Mat dst;
 
-        cv::Mat cpuRes;
-        cv::add(mat1, mat2, cpuRes);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuRes;
-        cv::gpu::add(gpu1, gpu2, gpuRes);
+        cv::gpu::subtract(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes);
 
-        return CheckNorm(cpuRes, gpuRes);
-    }
-};
+        gpuRes.download(dst);
+    );
 
-////////////////////////////////////////////////////////////////////////////////
-// Sub
-struct CV_GpuNppImageSubtractTest : public CV_GpuArithmTest
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, SubtractArray, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1)));
+
+struct SubtractScalar : ArithmTest {};
+
+TEST_P(SubtractScalar, Accuracy) 
 {
-    CV_GpuNppImageSubtractTest() : CV_GpuArithmTest( "GPU-NppImageSubtract", "subtract" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
 
-    int test( const Mat& mat1, const Mat& mat2 )
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        cv::Mat cpuRes;
-        cv::subtract(mat1, mat2, cpuRes);
+    cv::Scalar val(rng.uniform(0.1, 3.0), rng.uniform(0.1, 3.0));
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuRes;
-        cv::gpu::subtract(gpu1, gpu2, gpuRes);
+    PRINT_PARAM(val);
+    
+    cv::Mat dst_gold;
+    cv::subtract(mat1, val, dst_gold);
 
-        return CheckNorm(cpuRes, gpuRes);
-    }
-};
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::subtract(cv::gpu::GpuMat(mat1), val, gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    ASSERT_LE(checkNorm(dst_gold, dst), 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, SubtractScalar, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32FC1, CV_32FC2)));
 
 ////////////////////////////////////////////////////////////////////////////////
 // multiply
-struct CV_GpuNppImageMultiplyTest : public CV_GpuArithmTest
+
+struct MultiplyArray : ArithmTest {};
+
+TEST_P(MultiplyArray, Accuracy) 
 {
-    CV_GpuNppImageMultiplyTest() : CV_GpuArithmTest( "GPU-NppImageMultiply", "multiply" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    
+    cv::Mat dst_gold;
+    cv::multiply(mat1, mat2, dst_gold);
 
-    int test( const Mat& mat1, const Mat& mat2 )
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::Mat dst;
 
-	    cv::Mat cpuRes;
-	    cv::multiply(mat1, mat2, cpuRes);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
 
-	    GpuMat gpu1(mat1);
-	    GpuMat gpu2(mat2);
-	    GpuMat gpuRes;
-	    cv::gpu::multiply(gpu1, gpu2, gpuRes);
+        cv::gpu::multiply(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes);
 
-            return CheckNorm(cpuRes, gpuRes);
-    }
-};
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, MultiplyArray, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1)));
+
+struct MultiplyScalar : ArithmTest {};
+
+TEST_P(MultiplyScalar, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Scalar val(rng.uniform(0.1, 3.0), rng.uniform(0.1, 3.0));
+
+    PRINT_PARAM(val);
+    
+    cv::Mat dst_gold;
+    cv::multiply(mat1, val, dst_gold);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::multiply(cv::gpu::GpuMat(mat1), val, gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, MultiplyScalar, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32FC1)));
 
 ////////////////////////////////////////////////////////////////////////////////
 // divide
-struct CV_GpuNppImageDivideTest : public CV_GpuArithmTest
+
+struct DivideArray : ArithmTest {};
+
+TEST_P(DivideArray, Accuracy) 
 {
-    CV_GpuNppImageDivideTest() : CV_GpuArithmTest( "GPU-NppImageDivide", "divide" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    
+    cv::Mat dst_gold;
+    cv::divide(mat1, mat2, dst_gold);
 
-    int test( const Mat& mat1, const Mat& mat2 )
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::Mat dst;
 
-	    cv::Mat cpuRes;
-	    cv::divide(mat1, mat2, cpuRes);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
 
-	    GpuMat gpu1(mat1);
-	    GpuMat gpu2(mat2);
-	    GpuMat gpuRes;
-	    cv::gpu::divide(gpu1, gpu2, gpuRes);
+        cv::gpu::divide(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes);
 
-        return CheckNorm(cpuRes, gpuRes, 1.01f);
-    }
-};
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, DivideArray, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1)));
+
+struct DivideScalar : ArithmTest {};
+
+TEST_P(DivideScalar, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Scalar val(rng.uniform(0.1, 3.0), rng.uniform(0.1, 3.0));
+
+    PRINT_PARAM(val);
+    
+    cv::Mat dst_gold;
+    cv::divide(mat1, val, dst_gold);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::divide(cv::gpu::GpuMat(mat1), val, gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, DivideScalar, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32FC1)));
 
 ////////////////////////////////////////////////////////////////////////////////
 // transpose
-struct CV_GpuNppImageTransposeTest : public CV_GpuArithmTest
+
+struct Transpose : ArithmTest {};
+
+TEST_P(Transpose, Accuracy) 
 {
-    CV_GpuNppImageTransposeTest() : CV_GpuArithmTest( "GPU-NppImageTranspose", "transpose" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
 
-    int test( const Mat& mat1, const Mat& )
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::Mat dst_gold;
+    cv::transpose(mat1, dst_gold);
 
-        cv::Mat cpuRes;
-        cv::transpose(mat1, cpuRes);
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
 
-        GpuMat gpu1(mat1);
-        GpuMat gpuRes;
-        cv::gpu::transpose(gpu1, gpuRes);
+        cv::gpu::transpose(cv::gpu::GpuMat(mat1), gpuRes);
 
-        return CheckNorm(cpuRes, gpuRes);
-    }
-};
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Transpose, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_8SC4, CV_16UC2, CV_16SC2, CV_32SC1, CV_32SC2, CV_32FC1, CV_32FC2, CV_64FC1)));
 
 ////////////////////////////////////////////////////////////////////////////////
 // absdiff
-struct CV_GpuNppImageAbsdiffTest : public CV_GpuArithmTest
+
+struct AbsdiffArray : ArithmTest {};
+
+TEST_P(AbsdiffArray, Accuracy) 
 {
-    CV_GpuNppImageAbsdiffTest() : CV_GpuArithmTest( "GPU-NppImageAbsdiff", "absdiff" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    
+    cv::Mat dst_gold;
+    cv::absdiff(mat1, mat2, dst_gold);
 
-    int test( const Mat& mat1, const Mat& mat2 )
-    {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4 && mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+    cv::Mat dst;
 
-        cv::Mat cpuRes;
-        cv::absdiff(mat1, mat2, cpuRes);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuRes;
-        cv::gpu::absdiff(gpu1, gpu2, gpuRes);
+        cv::gpu::absdiff(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes);
 
-        return CheckNorm(cpuRes, gpuRes);
-    }
-};
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, AbsdiffArray, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1)));
+
+struct AbsdiffScalar : ArithmTest {};
+
+TEST_P(AbsdiffScalar, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Scalar val(rng.uniform(0.1, 3.0), rng.uniform(0.1, 3.0));
+
+    PRINT_PARAM(val);
+    
+    cv::Mat dst_gold;
+    cv::absdiff(mat1, val, dst_gold);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::absdiff(cv::gpu::GpuMat(mat1), val, gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, AbsdiffScalar, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32FC1)));
 
 ////////////////////////////////////////////////////////////////////////////////
 // compare
-struct CV_GpuNppImageCompareTest : public CV_GpuArithmTest
+
+struct Compare : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> > 
 {
-    CV_GpuNppImageCompareTest() : CV_GpuArithmTest( "GPU-NppImageCompare", "compare" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    int cmp_code;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mat1, mat2;
+
+    cv::Mat dst_gold;
+        
+    virtual void SetUp()
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = std::tr1::get<0>(GetParam());
+        cmp_code = std::tr1::get<1>(GetParam());
 
-        int cmp_codes[] = {CMP_EQ, CMP_GT, CMP_GE, CMP_LT, CMP_LE, CMP_NE};
-        const char* cmp_str[] = {"CMP_EQ", "CMP_GT", "CMP_GE", "CMP_LT", "CMP_LE", "CMP_NE"};
-        int cmp_num = sizeof(cmp_codes) / sizeof(int);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        int test_res = cvtest::TS::OK;
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        for (int i = 0; i < cmp_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nCompare operation: %s\n", cmp_str[i]);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat1 = cvtest::randomMat(rng, size, CV_32FC1, 1, 16, false);
+        mat2 = cvtest::randomMat(rng, size, CV_32FC1, 1, 16, false);
 
-            cv::Mat cpuRes;
-            cv::compare(mat1, mat2, cpuRes, cmp_codes[i]);
-
-            GpuMat gpu1(mat1);
-            GpuMat gpu2(mat2);
-            GpuMat gpuRes;
-            cv::gpu::compare(gpu1, gpu2, gpuRes, cmp_codes[i]);
-
-            if (CheckNorm(cpuRes, gpuRes) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
+        cv::compare(mat1, mat2, dst_gold, cmp_code);
     }
 };
 
+TEST_P(Compare, Accuracy) 
+{
+    static const char* cmp_codes[] = {"CMP_EQ", "CMP_GT", "CMP_GE", "CMP_LT", "CMP_LE", "CMP_NE"};
+    const char* cmpCodeStr = cmp_codes[cmp_code];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+    PRINT_PARAM(cmpCodeStr);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::compare(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuRes, cmp_code);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Compare, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values((int)cv::CMP_EQ, (int)cv::CMP_GT, (int)cv::CMP_GE, (int)cv::CMP_LT, (int)cv::CMP_LE, (int)cv::CMP_NE)));
+
 ////////////////////////////////////////////////////////////////////////////////
 // meanStdDev
-struct CV_GpuNppImageMeanStdDevTest : public CV_GpuArithmTest
+
+struct MeanStdDev : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImageMeanStdDevTest() : CV_GpuArithmTest( "GPU-NppImageMeanStdDev", "meanStdDev" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& )
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Scalar mean_gold;
+    cv::Scalar stddev_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_8UC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        Scalar cpumean;
-        Scalar cpustddev;
-        cv::meanStdDev(mat1, cpumean, cpustddev);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        Scalar gpumean;
-        Scalar gpustddev;
-        cv::gpu::meanStdDev(gpu1, gpumean, gpustddev);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        int test_res = cvtest::TS::OK;
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat = cvtest::randomMat(rng, size, CV_8UC1, 1, 255, false);
 
-        if (CheckNorm(cpumean, gpumean) != cvtest::TS::OK)
-        {
-            ts->printf(cvtest::TS::LOG, "\nMean FAILED\n");
-            test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        if (CheckNorm(cpustddev, gpustddev) != cvtest::TS::OK)
-        {
-            ts->printf(cvtest::TS::LOG, "\nStdDev FAILED\n");
-            test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
+        cv::meanStdDev(mat, mean_gold, stddev_gold);
     }
 };
 
+TEST_P(MeanStdDev, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Scalar mean;
+    cv::Scalar stddev;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::meanStdDev(cv::gpu::GpuMat(mat), mean, stddev);
+    );
+
+    EXPECT_NEAR(mean_gold[0], mean[0], 1e-5);
+    EXPECT_NEAR(mean_gold[1], mean[1], 1e-5);
+    EXPECT_NEAR(mean_gold[2], mean[2], 1e-5);
+    EXPECT_NEAR(mean_gold[3], mean[3], 1e-5);
+
+    EXPECT_NEAR(stddev_gold[0], stddev[0], 1e-5);
+    EXPECT_NEAR(stddev_gold[1], stddev[1], 1e-5);
+    EXPECT_NEAR(stddev_gold[2], stddev[2], 1e-5);
+    EXPECT_NEAR(stddev_gold[3], stddev[3], 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, MeanStdDev, testing::ValuesIn(devices()));
+
 ////////////////////////////////////////////////////////////////////////////////
-// norm
-struct CV_GpuNppImageNormTest : public CV_GpuArithmTest
+// normDiff
+
+static const int norms[] = {cv::NORM_INF, cv::NORM_L1, cv::NORM_L2};
+static const char* norms_str[] = {"NORM_INF", "NORM_L1", "NORM_L2"};
+
+struct NormDiff : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
 {
-    CV_GpuNppImageNormTest() : CV_GpuArithmTest( "GPU-NppImageNorm", "norm" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    int normIdx;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mat1, mat2;
+
+    double norm_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_8UC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = std::tr1::get<0>(GetParam());
+        normIdx = std::tr1::get<1>(GetParam());
 
-        int norms[] = {NORM_INF, NORM_L1, NORM_L2};
-        const char* norms_str[] = {"NORM_INF", "NORM_L1", "NORM_L2"};
-        int norms_num = sizeof(norms) / sizeof(int);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        int test_res = cvtest::TS::OK;
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        for (int i = 0; i < norms_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nNorm type: %s\n", norms_str[i]);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat1 = cvtest::randomMat(rng, size, CV_8UC1, 1, 255, false);
+        mat2 = cvtest::randomMat(rng, size, CV_8UC1, 1, 255, false);
 
-            double cpu_norm = cv::norm(mat1, mat2, norms[i]);
-
-            GpuMat gpu1(mat1);
-            GpuMat gpu2(mat2);
-            double gpu_norm = cv::gpu::norm(gpu1, gpu2, norms[i]);
-
-            if (CheckNorm(cpu_norm, gpu_norm) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
+        norm_gold = cv::norm(mat1, mat2, norms[normIdx]);
     }
 };
 
+TEST_P(NormDiff, Accuracy) 
+{
+    const char* normStr = norms_str[normIdx];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+    PRINT_PARAM(normStr);
+    
+    double norm;
+    
+    ASSERT_NO_THROW(
+        norm = cv::gpu::norm(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), norms[normIdx]);
+    );
+
+    EXPECT_NEAR(norm_gold, norm, 1e-6);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, NormDiff, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Range(0, 3)));
+
 ////////////////////////////////////////////////////////////////////////////////
 // flip
-struct CV_GpuNppImageFlipTest : public CV_GpuArithmTest
+
+struct Flip : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
 {
-    CV_GpuNppImageFlipTest() : CV_GpuArithmTest( "GPU-NppImageFlip", "flip" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int flip_code;
 
-    int test( const Mat& mat1, const Mat& )
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC4)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        flip_code = std::tr1::get<2>(GetParam());
 
-        int flip_codes[] = {0, 1, -1};
-        const char* flip_axis[] = {"X", "Y", "Both"};
-        int flip_codes_num = sizeof(flip_codes) / sizeof(int);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        int test_res = cvtest::TS::OK;
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        for (int i = 0; i < flip_codes_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nFlip Axis: %s\n", flip_axis[i]);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat = cvtest::randomMat(rng, size, type, 1, 255, false);
 
-            Mat cpu_res;
-            cv::flip(mat1, cpu_res, flip_codes[i]);
-
-            GpuMat gpu1(mat1);
-            GpuMat gpu_res;
-            cv::gpu::flip(gpu1, gpu_res, flip_codes[i]);
-
-            if (CheckNorm(cpu_res, gpu_res) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
+        cv::flip(mat, dst_gold, flip_code);
     }
 };
 
+TEST_P(Flip, Accuracy) 
+{
+    static const char* flip_axis[] = {"Both", "X", "Y"};
+    const char* flipAxisStr = flip_axis[flip_code + 1];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(flipAxisStr);
+    
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::flip(cv::gpu::GpuMat(mat), gpu_res, flip_code);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Flip, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC4),
+                        testing::Values(0, 1, -1)));
+
 ////////////////////////////////////////////////////////////////////////////////
 // LUT
-struct CV_GpuNppImageLUTTest : public CV_GpuArithmTest
+
+struct LUT : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
 {
-    CV_GpuNppImageLUTTest() : CV_GpuArithmTest( "GPU-NppImageLUT", "LUT" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    int type;
 
-    int test( const Mat& mat1, const Mat& )
+    cv::Size size;
+    cv::Mat mat;
+    cv::Mat lut;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_8UC1 && mat1.type() != CV_8UC3)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
 
-        cv::Mat lut(1, 256, CV_8UC1);
-        cv::RNG& rng = ts->get_rng();
-        rng.fill(lut, cv::RNG::UNIFORM, cv::Scalar::all(100), cv::Scalar::all(200));
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        cv::Mat cpuRes;
-        cv::LUT(mat1, lut, cpuRes);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        cv::gpu::GpuMat gpuRes;
-        cv::gpu::LUT(GpuMat(mat1), lut, gpuRes);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        mat = cvtest::randomMat(rng, size, type, 1, 255, false);
+        lut = cvtest::randomMat(rng, cv::Size(256, 1), CV_8UC1, 100, 200, false);
 
-        return CheckNorm(cpuRes, gpuRes);
+        cv::LUT(mat, lut, dst_gold);
     }
 };
 
+TEST_P(LUT, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::LUT(cv::gpu::GpuMat(mat), lut, gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, LUT, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8UC1, CV_8UC3)));
+
 ////////////////////////////////////////////////////////////////////////////////
 // exp
-struct CV_GpuNppImageExpTest : public CV_GpuArithmTest
+
+struct Exp : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImageExpTest() : CV_GpuArithmTest( "GPU-NppImageExp", "exp" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& )
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuRes;
-        cv::exp(mat1, cpuRes);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpuRes;
-        cv::gpu::exp(gpu1, gpuRes);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        return CheckNorm(cpuRes, gpuRes);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, CV_32FC1, -10.0, 2.0, false);        
+
+        cv::exp(mat, dst_gold);
     }
 };
 
+TEST_P(Exp, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::exp(cv::gpu::GpuMat(mat), gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Exp, testing::ValuesIn(devices()));
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// pow
+
+struct Pow : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    double power;
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {        
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());        
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        //size = cv::Size(2, 2);
+
+        mat = cvtest::randomMat(rng, size, type, 0.0, 100.0, false);        
+
+        if (mat.depth() == CV_32F)
+            power = rng.uniform(1.2f, 3.f);
+        else
+        {
+            int ipower = rng.uniform(2, 8);
+            power = (float)ipower;
+        }
+        cv::pow(mat, power, dst_gold);
+    }
+};
+
+TEST_P(Pow, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(power);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::pow(cv::gpu::GpuMat(mat), power, gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    /*std::cout  << mat << std::endl << std::endl;
+    std::cout  << dst << std::endl << std::endl;
+    std::cout  << dst_gold << std::endl;*/
+    EXPECT_MAT_NEAR(dst_gold, dst, 1);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Pow, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_32F, CV_32FC3)));
+
 ////////////////////////////////////////////////////////////////////////////////
 // log
-struct CV_GpuNppImageLogTest : public CV_GpuArithmTest
+
+struct Log : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImageLogTest() : CV_GpuArithmTest( "GPU-NppImageLog", "log" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& )
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuRes;
-        cv::log(mat1, cpuRes);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpuRes;
-        cv::gpu::log(gpu1, gpuRes);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        return CheckNorm(cpuRes, gpuRes);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 100.0, false);        
+
+        cv::log(mat, dst_gold);
     }
 };
 
+TEST_P(Log, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::log(cv::gpu::GpuMat(mat), gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Log, testing::ValuesIn(devices()));
+
 ////////////////////////////////////////////////////////////////////////////////
 // magnitude
-struct CV_GpuNppImageMagnitudeTest : public CV_GpuArithmTest
+
+struct Magnitude : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImageMagnitudeTest() : CV_GpuArithmTest( "GPU-NppImageMagnitude", "magnitude" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mat1, mat2;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuRes;
-        cv::magnitude(mat1, mat2, cpuRes);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuRes;
-        cv::gpu::magnitude(gpu1, gpu2, gpuRes);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        return CheckNorm(cpuRes, gpuRes);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat1 = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 100.0, false);
+        mat2 = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 100.0, false);       
+
+        cv::magnitude(mat1, mat2, dst_gold);
     }
 };
 
+TEST_P(Magnitude, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::magnitude(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Magnitude, testing::ValuesIn(devices()));
+
 ////////////////////////////////////////////////////////////////////////////////
 // phase
-struct CV_GpuNppImagePhaseTest : public CV_GpuArithmTest
+
+struct Phase : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImagePhaseTest() : CV_GpuArithmTest( "GPU-NppImagePhase", "phase" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mat1, mat2;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuRes;
-        cv::phase(mat1, mat2, cpuRes, true);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuRes;
-        cv::gpu::phase(gpu1, gpu2, gpuRes, true);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        return CheckNorm(cpuRes, gpuRes, 0.3f);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat1 = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 100.0, false);
+        mat2 = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 100.0, false);       
+
+        cv::phase(mat1, mat2, dst_gold);
     }
 };
 
+TEST_P(Phase, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpu_res;
+
+        cv::gpu::phase(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpu_res);
+
+        gpu_res.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Phase, testing::ValuesIn(devices()));
+
 ////////////////////////////////////////////////////////////////////////////////
 // cartToPolar
-struct CV_GpuNppImageCartToPolarTest : public CV_GpuArithmTest
+
+struct CartToPolar : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImageCartToPolarTest() : CV_GpuArithmTest( "GPU-NppImageCartToPolar", "cartToPolar" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mat1, mat2;
+
+    cv::Mat mag_gold;
+    cv::Mat angle_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuMag, cpuAngle;
-        cv::cartToPolar(mat1, mat2, cpuMag, cpuAngle);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuMag, gpuAngle;
-        cv::gpu::cartToPolar(gpu1, gpu2, gpuMag, gpuAngle);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        int magRes = CheckNorm(cpuMag, gpuMag);
-        int angleRes = CheckNorm(cpuAngle, gpuAngle, 0.005f);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
 
-        return magRes == cvtest::TS::OK && angleRes == cvtest::TS::OK ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC;
+        mat1 = cvtest::randomMat(rng, size, CV_32FC1, -100.0, 100.0, false);
+        mat2 = cvtest::randomMat(rng, size, CV_32FC1, -100.0, 100.0, false);       
+
+        cv::cartToPolar(mat1, mat2, mag_gold, angle_gold);
     }
 };
 
+TEST_P(CartToPolar, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat mag, angle;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuMag;
+        cv::gpu::GpuMat gpuAngle;
+
+        cv::gpu::cartToPolar(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), gpuMag, gpuAngle);
+
+        gpuMag.download(mag);
+        gpuAngle.download(angle);
+    );
+
+    EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+    EXPECT_MAT_NEAR(angle_gold, angle, 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, CartToPolar, testing::ValuesIn(devices()));
+
 ////////////////////////////////////////////////////////////////////////////////
 // polarToCart
-struct CV_GpuNppImagePolarToCartTest : public CV_GpuArithmTest
+
+struct PolarToCart : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuNppImagePolarToCartTest() : CV_GpuArithmTest( "GPU-NppImagePolarToCart", "polarToCart" ) {}
+    cv::gpu::DeviceInfo devInfo;
 
-    int test( const Mat& mat1, const Mat& mat2 )
+    cv::Size size;
+    cv::Mat mag;
+    cv::Mat angle;
+
+    cv::Mat x_gold;
+    cv::Mat y_gold;
+
+    virtual void SetUp() 
     {
-        if (mat1.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\tUnsupported type\t");
-            return cvtest::TS::OK;
-        }
+        devInfo = GetParam();
 
-        cv::Mat cpuX, cpuY;
-        cv::polarToCart(mat1, mat2, cpuX, cpuY);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        GpuMat gpu1(mat1);
-        GpuMat gpu2(mat2);
-        GpuMat gpuX, gpuY;
-        cv::gpu::polarToCart(gpu1, gpu2, gpuX, gpuY);
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        int xRes = CheckNorm(cpuX, gpuX);
-        int yRes = CheckNorm(cpuY, gpuY);
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
 
-        return xRes == cvtest::TS::OK && yRes == cvtest::TS::OK ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC;
+        mag = cvtest::randomMat(rng, size, CV_32FC1, -100.0, 100.0, false);
+        angle = cvtest::randomMat(rng, size, CV_32FC1, 0.0, 2.0 * CV_PI, false);       
+
+        cv::polarToCart(mag, angle, x_gold, y_gold);
     }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Min max
-
-struct CV_GpuMinMaxTest: public cvtest::BaseTest
+TEST_P(PolarToCart, Accuracy) 
 {
-    CV_GpuMinMaxTest() {}
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
 
-    cv::gpu::GpuMat buf;
+    cv::Mat x, y;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuX;
+        cv::gpu::GpuMat gpuY;
 
-    void run(int)
+        cv::gpu::polarToCart(cv::gpu::GpuMat(mag), cv::gpu::GpuMat(angle), gpuX, gpuY);
+
+        gpuX.download(x);
+        gpuY.download(y);
+    );
+
+    EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+    EXPECT_MAT_NEAR(y_gold, y, 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, PolarToCart, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////////////////////////////
+// minMax
+
+struct MinMax : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat;
+    cv::Mat mask;
+
+    double minVal_gold;
+    double maxVal_gold;
+
+    virtual void SetUp() 
     {
-        bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) &&
-                         gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-        int depth_end = double_ok ? CV_64F : CV_32F;
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
 
-        for (int depth = CV_8U; depth <= depth_end; ++depth)
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+        mask = cvtest::randomMat(rng, size, CV_8UC1, 0, 2, false);
+
+        if (type != CV_8S)
         {
-            for (int i = 0; i < 3; ++i)
-            {
-                int rows = 1 + rand() % 1000;
-                int cols = 1 + rand() % 1000;
-                test(rows, cols, 1, depth);
-                test_masked(rows, cols, 1, depth);
-            }
-        }
-    }
-
-    void test(int rows, int cols, int cn, int depth)
-    {
-        cv::Mat src(rows, cols, CV_MAKE_TYPE(depth, cn));
-        cv::RNG& rng = ts->get_rng();
-        rng.fill(src, RNG::UNIFORM, Scalar(0), Scalar(255));
-
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-
-        if (depth != CV_8S)
-        {
-            cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
-        }
-        else 
-        {
-            minVal = std::numeric_limits<double>::max();
-            maxVal = -std::numeric_limits<double>::max();
-            for (int i = 0; i < src.rows; ++i)
-                for (int j = 0; j < src.cols; ++j)
-                {
-                    signed char val = src.at<signed char>(i, j);
-                    if (val < minVal) minVal = val;
-                    if (val > maxVal) maxVal = val;
-                }
-        }
-
-        double minVal_, maxVal_;
-        cv::gpu::minMax(cv::gpu::GpuMat(src), &minVal_, &maxVal_, cv::gpu::GpuMat(), buf);
-       
-        if (abs(minVal - minVal_) > 1e-3f)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nfail: minVal=%f minVal_=%f rows=%d cols=%d depth=%d cn=%d\n", minVal, minVal_, rows, cols, depth, cn);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-        }
-        if (abs(maxVal - maxVal_) > 1e-3f)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nfail: maxVal=%f maxVal_=%f rows=%d cols=%d depth=%d cn=%d\n", maxVal, maxVal_, rows, cols, depth, cn);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-        }
-    }  
-
-    void test_masked(int rows, int cols, int cn, int depth)
-    {
-        cv::Mat src(rows, cols, CV_MAKE_TYPE(depth, cn));
-        cv::RNG& rng = ts->get_rng();
-        rng.fill(src, RNG::UNIFORM, Scalar(0), Scalar(255));
-
-        cv::Mat mask(src.size(), CV_8U);
-        rng.fill(mask, RNG::UNIFORM, Scalar(0), Scalar(2));
-
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-
-        Mat src_ = src.reshape(1);
-        if (depth != CV_8S)
-        {
-            cv::minMaxLoc(src_, &minVal, &maxVal, &minLoc, &maxLoc, mask);
+            cv::minMaxLoc(mat, &minVal_gold, &maxVal_gold, 0, 0, mask);
         }
         else 
         {
             // OpenCV's minMaxLoc doesn't support CV_8S type 
-            minVal = std::numeric_limits<double>::max();
-            maxVal = -std::numeric_limits<double>::max();
-            for (int i = 0; i < src_.rows; ++i)
-                for (int j = 0; j < src_.cols; ++j)
-                {
-                    char val = src_.at<char>(i, j);
-                    if (mask.at<unsigned char>(i, j)) { if (val < minVal) minVal = val; }
-                    if (mask.at<unsigned char>(i, j)) { if (val > maxVal) maxVal = val; }
-                }
-        }
-
-        double minVal_, maxVal_;
-        cv::Point minLoc_, maxLoc_;        
-        cv::gpu::minMax(cv::gpu::GpuMat(src), &minVal_, &maxVal_, cv::gpu::GpuMat(mask), buf);
-       
-        if (abs(minVal - minVal_) > 1e-3f)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nfail: minVal=%f minVal_=%f rows=%d cols=%d depth=%d cn=%d\n", minVal, minVal_, rows, cols, depth, cn);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-        }
-        if (abs(maxVal - maxVal_) > 1e-3f)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nfail: maxVal=%f maxVal_=%f rows=%d cols=%d depth=%d cn=%d\n", maxVal, maxVal_, rows, cols, depth, cn);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-        }
-    }  
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Min max loc
-
-struct CV_GpuMinMaxLocTest: public cvtest::BaseTest
-{
-    CV_GpuMinMaxLocTest() {}
-
-    GpuMat valbuf, locbuf;
-
-    void run(int)
-    {
-        bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) &&
-                         gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-        int depth_end = double_ok ? CV_64F : CV_32F;
-
-        for (int depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            int rows = 1, cols = 3;
-            test(rows, cols, depth);
-            for (int i = 0; i < 4; ++i)
+            minVal_gold = std::numeric_limits<double>::max();
+            maxVal_gold = -std::numeric_limits<double>::max();
+            for (int i = 0; i < mat.rows; ++i)
             {
-                int rows = 1 + rand() % 1000;
-                int cols = 1 + rand() % 1000;
-                test(rows, cols, depth);
-            }
-        }
-    }
-
-    void test(int rows, int cols, int depth)
-    {
-        cv::Mat src(rows, cols, depth);
-        cv::RNG& rng = ts->get_rng();
-        rng.fill(src, RNG::UNIFORM, Scalar(0), Scalar(255));
-
-        cv::Mat mask(src.size(), CV_8U);
-        rng.fill(mask, RNG::UNIFORM, Scalar(0), Scalar(2));
-
-        // At least one of the mask elements must be non zero as OpenCV returns 0
-        // in such case, when our implementation returns maximum or minimum value
-        mask.at<unsigned char>(0, 0) = 1;
-
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-
-        if (depth != CV_8S)       
-            cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, mask);
-        else 
-        {
-            // OpenCV's minMaxLoc doesn't support CV_8S type 
-            minVal = std::numeric_limits<double>::max();
-            maxVal = -std::numeric_limits<double>::max();
-            for (int i = 0; i < src.rows; ++i)
-                for (int j = 0; j < src.cols; ++j)
+                const signed char* mat_row = mat.ptr<signed char>(i);
+                const unsigned char* mask_row = mask.ptr<unsigned char>(i);
+                for (int j = 0; j < mat.cols; ++j)
                 {
-                    char val = src.at<char>(i, j);
-                    if (mask.at<unsigned char>(i, j))
-                    {
-                        if (val < minVal) { minVal = val; minLoc = cv::Point(j, i); }
-                        if (val > maxVal) { maxVal = val; maxLoc = cv::Point(j, i); }
+                    if (mask_row[j]) 
+                    { 
+                        signed char val = mat_row[j];
+                        if (val < minVal_gold) minVal_gold = val;
+                        if (val > maxVal_gold) maxVal_gold = val; 
                     }
                 }
+            }
         }
-
-        double minVal_, maxVal_;
-        cv::Point minLoc_, maxLoc_;        
-        cv::gpu::minMaxLoc(cv::gpu::GpuMat(src), &minVal_, &maxVal_, &minLoc_, &maxLoc_, cv::gpu::GpuMat(mask), valbuf, locbuf);
-
-        CHECK(minVal == minVal_, cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(maxVal == maxVal_, cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(0 == memcmp(src.ptr(minLoc.y) + minLoc.x * src.elemSize(), src.ptr(minLoc_.y) + minLoc_.x * src.elemSize(), src.elemSize()),  
-              cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(0 == memcmp(src.ptr(maxLoc.y) + maxLoc.x * src.elemSize(), src.ptr(maxLoc_.y) + maxLoc_.x * src.elemSize(), src.elemSize()),  
-              cvtest::TS::FAIL_INVALID_OUTPUT);
-    }  
+    }
 };
 
+TEST_P(MinMax, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    double minVal, maxVal;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::minMax(cv::gpu::GpuMat(mat), &minVal, &maxVal, cv::gpu::GpuMat(mask));
+    );
+
+    EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+    EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, MinMax, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
+
+////////////////////////////////////////////////////////////////////////////////
+// minMaxLoc
+
+struct MinMaxLoc : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat;
+    cv::Mat mask;
+
+    double minVal_gold;
+    double maxVal_gold;
+    cv::Point minLoc_gold;
+    cv::Point maxLoc_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+        mask = cvtest::randomMat(rng, size, CV_8UC1, 0, 2, false);
+
+        if (type != CV_8S)
+        {
+            cv::minMaxLoc(mat, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+        }
+        else 
+        {
+            // OpenCV's minMaxLoc doesn't support CV_8S type 
+            minVal_gold = std::numeric_limits<double>::max();
+            maxVal_gold = -std::numeric_limits<double>::max();
+            for (int i = 0; i < mat.rows; ++i)
+            {
+                const signed char* mat_row = mat.ptr<signed char>(i);
+                const unsigned char* mask_row = mask.ptr<unsigned char>(i);
+                for (int j = 0; j < mat.cols; ++j)
+                {
+                    if (mask_row[j]) 
+                    { 
+                        signed char val = mat_row[j];
+                        if (val < minVal_gold) { minVal_gold = val; minLoc_gold = cv::Point(j, i); }
+                        if (val > maxVal_gold) { maxVal_gold = val; maxLoc_gold = cv::Point(j, i); }
+                    }
+                }
+            }
+        }
+    }
+};
+
+TEST_P(MinMaxLoc, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    double minVal, maxVal;
+    cv::Point minLoc, maxLoc;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::minMaxLoc(cv::gpu::GpuMat(mat), &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(mask));
+    );
+
+    EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+    EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+    int cmpMinVals = memcmp(mat.data + minLoc_gold.y * mat.step + minLoc_gold.x * mat.elemSize(), 
+                            mat.data + minLoc.y * mat.step + minLoc.x * mat.elemSize(), 
+                            mat.elemSize());
+    int cmpMaxVals = memcmp(mat.data + maxLoc_gold.y * mat.step + maxLoc_gold.x * mat.elemSize(), 
+                            mat.data + maxLoc.y * mat.step + maxLoc.x * mat.elemSize(), 
+                            mat.elemSize());
+
+    EXPECT_EQ(0, cmpMinVals);
+    EXPECT_EQ(0, cmpMaxVals);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, MinMaxLoc, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
+
 ////////////////////////////////////////////////////////////////////////////
-// Count non zero
-struct CV_GpuCountNonZeroTest: cvtest::BaseTest 
+// countNonZero
+
+struct CountNonZero : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
 {
-    CV_GpuCountNonZeroTest(){}
+    cv::gpu::DeviceInfo devInfo;
+    int type;
 
-    void run(int) 
+    cv::Size size;
+    cv::Mat mat;
+
+    int n_gold;
+
+    virtual void SetUp() 
     {
-        int depth_end;
-        if (cv::gpu::DeviceInfo().supports(cv::gpu::NATIVE_DOUBLE))
-            depth_end = CV_64F;
-        else
-            depth_end = CV_32F;
-        for (int depth = CV_8U; depth <= CV_32F; ++depth)
-        {
-            for (int i = 0; i < 4; ++i)
-            {
-                int rows = 1 + rand() % 1000;
-                int cols = 1 + rand() % 1000;
-                test(rows, cols, depth);
-            }
-        }
-    }
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
 
-    void test(int rows, int cols, int depth)
-    {
-        cv::Mat src(rows, cols, depth);
-        cv::RNG rng;
-        if (depth == 5)
-            rng.fill(src, RNG::UNIFORM, Scalar(-1000.f), Scalar(1000.f));
-        else if (depth == 6)
-            rng.fill(src, RNG::UNIFORM, Scalar(-1000.), Scalar(1000.));
-        else
-            for (int i = 0; i < src.rows; ++i)
-            { 
-                Mat row(1, src.cols * src.elemSize(), CV_8U, src.ptr(i));
-                rng.fill(row, RNG::UNIFORM, Scalar(0), Scalar(256));
-            }
+        cv::gpu::setDevice(devInfo.deviceID());
 
-        int n_gold = cv::countNonZero(src);
-        int n = cv::gpu::countNonZero(cv::gpu::GpuMat(src));
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        if (n != n_gold)
-        {
-            ts->printf(cvtest::TS::LOG, "%d %d %d %d %d\n", n, n_gold, depth, cols, rows);
-            n_gold = cv::countNonZero(src);
-        }
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
 
-        CHECK(n == n_gold, cvtest::TS::FAIL_INVALID_OUTPUT);
+        cv::Mat matBase = cvtest::randomMat(rng, size, CV_8U, 0.0, 1.0, false);
+        matBase.convertTo(mat, type);
+
+        n_gold = cv::countNonZero(mat);
     }
 };
 
+TEST_P(CountNonZero, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    int n;
+    
+    ASSERT_NO_THROW(
+        n = cv::gpu::countNonZero(cv::gpu::GpuMat(mat));
+    );
+
+    ASSERT_EQ(n_gold, n);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, CountNonZero, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
 
 //////////////////////////////////////////////////////////////////////////////
 // sum
 
-struct CV_GpuSumTest: cvtest::BaseTest 
+struct Sum : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
 {
-    CV_GpuSumTest() {}
+    cv::gpu::DeviceInfo devInfo;
+    int type;
 
-    void run(int) 
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Scalar sum_gold;
+
+    virtual void SetUp() 
     {
-        Mat src;
-        Scalar a, b;
-        double max_err = 1e-5;
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
 
-        int typemax = CV_32F;
-        for (int type = CV_8U; type <= typemax; ++type)
-        {
-            //
-            // sum
-            //
+        cv::gpu::setDevice(devInfo.deviceID());
 
-            gen(1 + rand() % 500, 1 + rand() % 500, CV_MAKETYPE(type, 1), src);
-            a = sum(src);
-            b = sum(GpuMat(src));
-            if (abs(a[0] - b[0]) > src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "1 cols: %d, rows: %d, expected: %f, actual: %f\n", src.cols, src.rows, a[0], b[0]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-            gen(1 + rand() % 500, 1 + rand() % 500, CV_MAKETYPE(type, 2), src);
-            a = sum(src);
-            b = sum(GpuMat(src));
-            if (abs(a[0] - b[0]) + abs(a[1] - b[1]) > src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "2 cols: %d, rows: %d, expected: %f, actual: %f\n", src.cols, src.rows, a[1], b[1]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
 
-            gen(1 + rand() % 500, 1 + rand() % 500, CV_MAKETYPE(type, 3), src);
-            a = sum(src);
-            b = sum(GpuMat(src));
-            if (abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2])> src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "3 cols: %d, rows: %d, expected: %f, actual: %f\n", src.cols, src.rows, a[2], b[2]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-
-            gen(1 + rand() % 500, 1 + rand() % 500, CV_MAKETYPE(type, 4), src);
-            a = sum(src);
-            b = sum(GpuMat(src));
-            if (abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2]) + abs(a[3] - b[3])> src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "4 cols: %d, rows: %d, expected: %f, actual: %f\n", src.cols, src.rows, a[3], b[3]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-
-            gen(1 + rand() % 500, 1 + rand() % 500, type, src);
-            a = sum(src);
-            b = sum(GpuMat(src));
-            if (abs(a[0] - b[0]) > src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "cols: %d, rows: %d, expected: %f, actual: %f\n", src.cols, src.rows, a[0], b[0]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-
-            //
-            // absSum
-            //
-
-            gen(1 + rand() % 200, 1 + rand() % 200, CV_MAKETYPE(type, 1), src);
-            b = absSum(GpuMat(src));
-            a = norm(src, NORM_L1);
-            if (abs(a[0] - b[0]) > src.size().area() * max_err)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "type: %d, cols: %d, rows: %d, expected: %f, actual: %f\n", type, src.cols, src.rows, a[0], b[0]);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-
-            //
-            // sqrSum
-            //
-
-            if (type != CV_8S)
-            {
-                gen(1 + rand() % 200, 1 + rand() % 200, CV_MAKETYPE(type, 1), src);
-                b = sqrSum(GpuMat(src));
-                Mat sqrsrc;
-                multiply(src, src, sqrsrc);
-                a = sum(sqrsrc);
-                if (abs(a[0] - b[0]) > src.size().area() * max_err)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "type: %d, cols: %d, rows: %d, expected: %f, actual: %f\n", type, src.cols, src.rows, a[0], b[0]);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-                gen(1 + rand() % 200, 1 + rand() % 200, CV_MAKETYPE(type, 2), src);
-                b = sqrSum(GpuMat(src));
-                multiply(src, src, sqrsrc);
-                a = sum(sqrsrc);
-                if (abs(a[0] - b[0]) + abs(a[1] - b[1])> src.size().area() * max_err * 2)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "type: %d, cols: %d, rows: %d, expected: %f, actual: %f\n", type, src.cols, src.rows, a[0], b[0]);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-                gen(1 + rand() % 200, 1 + rand() % 200, CV_MAKETYPE(type, 3), src);
-                b = sqrSum(GpuMat(src));
-                multiply(src, src, sqrsrc);
-                a = sum(sqrsrc);
-                if (abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2])> src.size().area() * max_err * 3)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "type: %d, cols: %d, rows: %d, expected: %f, actual: %f\n", type, src.cols, src.rows, a[0], b[0]);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-                gen(1 + rand() % 200, 1 + rand() % 200, CV_MAKETYPE(type, 4), src);
-                b = sqrSum(GpuMat(src));
-                multiply(src, src, sqrsrc);
-                a = sum(sqrsrc);
-                if (abs(a[0] - b[0]) + abs(a[1] - b[1]) + abs(a[2] - b[2]) + abs(a[3] - b[3])> src.size().area() * max_err * 4)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "type: %d, cols: %d, rows: %d, expected: %f, actual: %f\n", type, src.cols, src.rows, a[0], b[0]);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-            }
-        }
-    }
-
-    void gen(int cols, int rows, int type, Mat& m)
-    {
-        m.create(rows, cols, type);
-        RNG rng;
-        rng.fill(m, RNG::UNIFORM, Scalar::all(0), Scalar::all(16));
+        mat = cvtest::randomMat(rng, size, CV_8U, 0.0, 10.0, false);
 
+        sum_gold = cv::sum(mat);
     }
 };
 
-TEST(add, accuracy) { CV_GpuNppImageAddTest test; test.safe_run(); }
-TEST(subtract, accuracy) { CV_GpuNppImageSubtractTest test; test.safe_run(); }
-TEST(multiply, accuracy) { CV_GpuNppImageMultiplyTest test; test.safe_run(); }
-TEST(divide, accuracy) { CV_GpuNppImageDivideTest test; test.safe_run(); }
-TEST(transpose, accuracy) { CV_GpuNppImageTransposeTest test; test.safe_run(); }
-TEST(absdiff, accuracy) { CV_GpuNppImageAbsdiffTest test; test.safe_run(); }
-TEST(compare, accuracy) { CV_GpuNppImageCompareTest test; test.safe_run(); }
-TEST(meanStdDev, accuracy) { CV_GpuNppImageMeanStdDevTest test; test.safe_run(); }
-TEST(normDiff, accuracy) { CV_GpuNppImageNormTest test; test.safe_run(); }
-TEST(flip, accuracy) { CV_GpuNppImageFlipTest test; test.safe_run(); }
-TEST(LUT, accuracy) { CV_GpuNppImageLUTTest test; test.safe_run(); }
-TEST(exp, accuracy) { CV_GpuNppImageExpTest test; test.safe_run(); }
-TEST(log, accuracy) { CV_GpuNppImageLogTest test; test.safe_run(); }
-TEST(magnitude, accuracy) { CV_GpuNppImageMagnitudeTest test; test.safe_run(); }
-TEST(phase, accuracy) { CV_GpuNppImagePhaseTest test; test.safe_run(); }
-TEST(cartToPolar, accuracy) { CV_GpuNppImageCartToPolarTest test; test.safe_run(); }
-TEST(polarToCart, accuracy) { CV_GpuNppImagePolarToCartTest test; test.safe_run(); }
-TEST(minMax, accuracy) { CV_GpuMinMaxTest test; test.safe_run(); }
-TEST(minMaxLoc, accuracy) { CV_GpuMinMaxLocTest test; test.safe_run(); }
-TEST(countNonZero, accuracy) { CV_GpuCountNonZeroTest test; test.safe_run(); }
-TEST(sum, accuracy) { CV_GpuSumTest test; test.safe_run(); }
+TEST_P(Sum, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Scalar sum;
+    
+    ASSERT_NO_THROW(
+        sum = cv::gpu::sum(cv::gpu::GpuMat(mat));
+    );
+
+    EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[2], sum_gold[2], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[3], sum_gold[3], mat.size().area() * 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, Sum, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
+
+struct AbsSum : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Scalar sum_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, CV_8U, 0.0, 10.0, false);
+
+        sum_gold = cv::norm(mat, cv::NORM_L1);
+    }
+};
+
+TEST_P(AbsSum, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Scalar sum;
+    
+    ASSERT_NO_THROW(
+        sum = cv::gpu::absSum(cv::gpu::GpuMat(mat));
+    );
+
+    EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[2], sum_gold[2], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[3], sum_gold[3], mat.size().area() * 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, AbsSum, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
+
+struct SqrSum : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Scalar sum_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat = cvtest::randomMat(rng, size, CV_8U, 0.0, 10.0, false);
+ 
+        cv::Mat sqrmat;
+        cv::multiply(mat, mat, sqrmat);
+        sum_gold = cv::sum(sqrmat);
+    }
+};
+
+TEST_P(SqrSum, Accuracy) 
+{
+    if (type == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Scalar sum;
+    
+    ASSERT_NO_THROW(
+        sum = cv::gpu::sqrSum(cv::gpu::GpuMat(mat));
+    );
+
+    EXPECT_NEAR(sum[0], sum_gold[0], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[1], sum_gold[1], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[2], sum_gold[2], mat.size().area() * 1e-5);
+    EXPECT_NEAR(sum[3], sum_gold[3], mat.size().area() * 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, SqrSum, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)));
+
+//////////////////////////////////////////////////////////////////////////////
+// bitwise
+
+struct BitwiseNot : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat.create(size, type);
+        
+        for (int i = 0; i < mat.rows; ++i)
+        {
+            cv::Mat row(1, static_cast<int>(mat.cols * mat.elemSize()), CV_8U, (void*)mat.ptr(i));
+            rng.fill(row, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+        }
+
+        dst_gold = ~mat;
+    }
+};
+
+TEST_P(BitwiseNot, Accuracy) 
+{
+    if (mat.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+
+        cv::gpu::bitwise_not(cv::gpu::GpuMat(mat), dev_dst);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, BitwiseNot, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::ValuesIn(all_types())));
+
+struct BitwiseOr : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat1;
+    cv::Mat mat2;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat1.create(size, type);
+        mat2.create(size, type);
+        
+        for (int i = 0; i < mat1.rows; ++i)
+        {
+            cv::Mat row1(1, static_cast<int>(mat1.cols * mat1.elemSize()), CV_8U, (void*)mat1.ptr(i));
+            rng.fill(row1, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+
+            cv::Mat row2(1, static_cast<int>(mat2.cols * mat2.elemSize()), CV_8U, (void*)mat2.ptr(i));
+            rng.fill(row2, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+        }
+
+        dst_gold = mat1 | mat2;
+    }
+};
+
+TEST_P(BitwiseOr, Accuracy) 
+{
+    if (mat1.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+
+        cv::gpu::bitwise_or(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), dev_dst);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, BitwiseOr, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::ValuesIn(all_types())));
+
+struct BitwiseAnd : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat1;
+    cv::Mat mat2;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat1.create(size, type);
+        mat2.create(size, type);
+        
+        for (int i = 0; i < mat1.rows; ++i)
+        {
+            cv::Mat row1(1, static_cast<int>(mat1.cols * mat1.elemSize()), CV_8U, (void*)mat1.ptr(i));
+            rng.fill(row1, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+
+            cv::Mat row2(1, static_cast<int>(mat2.cols * mat2.elemSize()), CV_8U, (void*)mat2.ptr(i));
+            rng.fill(row2, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+        }
+
+        dst_gold = mat1 & mat2;
+    }
+};
+
+TEST_P(BitwiseAnd, Accuracy) 
+{
+    if (mat1.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+
+        cv::gpu::bitwise_and(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), dev_dst);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, BitwiseAnd, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::ValuesIn(all_types())));
+
+struct BitwiseXor : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat1;
+    cv::Mat mat2;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+
+        mat1.create(size, type);
+        mat2.create(size, type);
+        
+        for (int i = 0; i < mat1.rows; ++i)
+        {
+            cv::Mat row1(1, static_cast<int>(mat1.cols * mat1.elemSize()), CV_8U, (void*)mat1.ptr(i));
+            rng.fill(row1, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+
+            cv::Mat row2(1, static_cast<int>(mat2.cols * mat2.elemSize()), CV_8U, (void*)mat2.ptr(i));
+            rng.fill(row2, cv::RNG::UNIFORM, cv::Scalar(0), cv::Scalar(255));
+        }
+
+        dst_gold = mat1 ^ mat2;
+    }
+};
+
+TEST_P(BitwiseXor, Accuracy) 
+{
+    if (mat1.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type)
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+
+        cv::gpu::bitwise_xor(cv::gpu::GpuMat(mat1), cv::gpu::GpuMat(mat2), dev_dst);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Arithm, BitwiseXor, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::ValuesIn(all_types())));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_bitwise_oper.cpp b/modules/gpu/test/test_bitwise_oper.cpp
deleted file mode 100644
index 6b05053e13..0000000000
--- a/modules/gpu/test/test_bitwise_oper.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*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*/
-
-#include <iostream>
-#include <limits>
-#include "test_precomp.hpp"
-
-#define CHECK(pred, err) if (!(pred)) { \
-    ts->printf(cvtest::TS::CONSOLE, "Fail: \"%s\" at line: %d\n", #pred, __LINE__); \
-    ts->set_failed_test_info(err); \
-    return; }
-
-using namespace cv;
-using namespace std;
-
-struct CV_GpuBitwiseTest: public cvtest::BaseTest
-{
-    CV_GpuBitwiseTest() {}
-
-    void run(int)
-    {
-        int rows, cols;
-
-        bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                         gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-        int depth_end = double_ok ? CV_64F : CV_32F;
-
-        for (int depth = CV_8U; depth <= depth_end; ++depth)
-            for (int cn = 1; cn <= 4; ++cn)
-                for (int attempt = 0; attempt < 3; ++attempt)
-                {
-                    rows = 1 + rand() % 100;
-                    cols = 1 + rand() % 100;
-                    test_bitwise_not(rows, cols, CV_MAKETYPE(depth, cn));
-                    test_bitwise_or(rows, cols, CV_MAKETYPE(depth, cn));
-                    test_bitwise_and(rows, cols, CV_MAKETYPE(depth, cn));
-                    test_bitwise_xor(rows, cols, CV_MAKETYPE(depth, cn));
-                }
-    }
-
-    void test_bitwise_not(int rows, int cols, int type)
-    {
-        Mat src(rows, cols, type);
-
-        RNG rng;
-        for (int i = 0; i < src.rows; ++i)
-        {
-            Mat row(1, src.cols * src.elemSize(), CV_8U, src.ptr(i));
-            rng.fill(row, RNG::UNIFORM, Scalar(0), Scalar(255));
-        }
-
-        Mat dst_gold = ~src;
-
-        gpu::GpuMat mask(src.size(), CV_8U);
-        mask.setTo(Scalar(1));
-
-        gpu::GpuMat dst;
-        gpu::bitwise_not(gpu::GpuMat(src), dst);
-
-        CHECK(dst_gold.size() == dst.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold.type() == dst.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-
-        Mat dsth(dst);
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold.ptr(i), dsth.ptr(i), dst_gold.cols * dst_gold.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT);
-
-        dst.setTo(Scalar::all(0));
-        gpu::bitwise_not(gpu::GpuMat(src), dst, mask);
-
-        CHECK(dst_gold.size() == dst.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold.type() == dst.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-
-        dsth = dst;
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold.ptr(i), dsth.ptr(i), dst_gold.cols * dst_gold.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-    }
-
-    void test_bitwise_or(int rows, int cols, int type)
-    {
-        Mat src1(rows, cols, type);
-        Mat src2(rows, cols, type);
-
-        RNG rng;
-        for (int i = 0; i < src1.rows; ++i)
-        {
-            Mat row1(1, src1.cols * src1.elemSize(), CV_8U, src1.ptr(i));
-            rng.fill(row1, RNG::UNIFORM, Scalar(0), Scalar(255));
-            Mat row2(1, src2.cols * src2.elemSize(), CV_8U, src2.ptr(i));
-            rng.fill(row2, RNG::UNIFORM, Scalar(0), Scalar(255));
-        }
-
-        Mat dst_gold = src1 | src2;
-        gpu::GpuMat dst = gpu::GpuMat(src1) | gpu::GpuMat(src2);
-
-        CHECK(dst_gold.size() == dst.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold.type() == dst.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        Mat dsth(dst);
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold.ptr(i), dsth.ptr(i), dst_gold.cols * dst_gold.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-
-        Mat mask(src1.size(), CV_8U);
-        randu(mask, Scalar(0), Scalar(255));
-
-        Mat dst_gold2(dst_gold.size(), dst_gold.type()); dst_gold2.setTo(Scalar::all(0));
-        gpu::GpuMat dst2(dst.size(), dst.type()); dst2.setTo(Scalar::all(0));
-        bitwise_or(src1, src2, dst_gold2, mask);
-        gpu::bitwise_or(gpu::GpuMat(src1), gpu::GpuMat(src2), dst2, gpu::GpuMat(mask));
-
-        CHECK(dst_gold2.size() == dst2.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold2.type() == dst2.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        dsth = dst2;
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold2.ptr(i), dsth.ptr(i), dst_gold2.cols * dst_gold2.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-    }
-
-    void test_bitwise_and(int rows, int cols, int type)
-    {
-        Mat src1(rows, cols, type);
-        Mat src2(rows, cols, type);
-
-        RNG rng;
-        for (int i = 0; i < src1.rows; ++i)
-        {
-            Mat row1(1, src1.cols * src1.elemSize(), CV_8U, src1.ptr(i));
-            rng.fill(row1, RNG::UNIFORM, Scalar(0), Scalar(255));
-            Mat row2(1, src2.cols * src2.elemSize(), CV_8U, src2.ptr(i));
-            rng.fill(row2, RNG::UNIFORM, Scalar(0), Scalar(255));
-        }
-
-        Mat dst_gold = src1 & src2;
-
-        gpu::GpuMat dst = gpu::GpuMat(src1) & gpu::GpuMat(src2);
-
-        CHECK(dst_gold.size() == dst.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold.type() == dst.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        Mat dsth(dst);
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold.ptr(i), dsth.ptr(i), dst_gold.cols * dst_gold.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-
-
-        Mat mask(src1.size(), CV_8U);
-        randu(mask, Scalar(0), Scalar(255));
-
-        Mat dst_gold2(dst_gold.size(), dst_gold.type()); dst_gold2.setTo(Scalar::all(0));
-        gpu::GpuMat dst2(dst.size(), dst.type()); dst2.setTo(Scalar::all(0));
-        bitwise_and(src1, src2, dst_gold2, mask);
-        gpu::bitwise_and(gpu::GpuMat(src1), gpu::GpuMat(src2), dst2, gpu::GpuMat(mask));
-
-        CHECK(dst_gold2.size() == dst2.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold2.type() == dst2.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        dsth = dst2;
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold2.ptr(i), dsth.ptr(i), dst_gold2.cols * dst_gold2.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-    }
-
-    void test_bitwise_xor(int rows, int cols, int type)
-    {
-        Mat src1(rows, cols, type);
-        Mat src2(rows, cols, type);
-
-        RNG rng;
-        for (int i = 0; i < src1.rows; ++i)
-        {
-            Mat row1(1, src1.cols * src1.elemSize(), CV_8U, src1.ptr(i));
-            rng.fill(row1, RNG::UNIFORM, Scalar(0), Scalar(255));
-            Mat row2(1, src2.cols * src2.elemSize(), CV_8U, src2.ptr(i));
-            rng.fill(row2, RNG::UNIFORM, Scalar(0), Scalar(255));
-        }
-
-        Mat dst_gold = src1 ^ src2;
-
-        gpu::GpuMat dst = gpu::GpuMat(src1) ^ gpu::GpuMat(src2);
-
-        CHECK(dst_gold.size() == dst.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold.type() == dst.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        Mat dsth(dst);
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold.ptr(i), dsth.ptr(i), dst_gold.cols * dst_gold.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-
-
-        Mat mask(src1.size(), CV_8U);
-        randu(mask, Scalar(0), Scalar(255));
-
-        Mat dst_gold2(dst_gold.size(), dst_gold.type()); dst_gold2.setTo(Scalar::all(0));
-        gpu::GpuMat dst2(dst.size(), dst.type()); dst2.setTo(Scalar::all(0));
-        bitwise_xor(src1, src2, dst_gold2, mask);
-        gpu::bitwise_xor(gpu::GpuMat(src1), gpu::GpuMat(src2), dst2, gpu::GpuMat(mask));
-
-        CHECK(dst_gold2.size() == dst2.size(), cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(dst_gold2.type() == dst2.type(), cvtest::TS::FAIL_INVALID_OUTPUT);        
-        dsth = dst2;
-        for (int i = 0; i < dst_gold.rows; ++i)       
-            CHECK(memcmp(dst_gold2.ptr(i), dsth.ptr(i), dst_gold2.cols * dst_gold2.elemSize()) == 0, cvtest::TS::FAIL_INVALID_OUTPUT)
-    }
-};
-
-TEST(BitwiseOperations, accuracy) { CV_GpuBitwiseTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_blend.cpp b/modules/gpu/test/test_blend.cpp
deleted file mode 100644
index 947969593c..0000000000
--- a/modules/gpu/test/test_blend.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
-
-TEST(blendLinear, accuracy_on_8U)
-{
-    RNG& rng = cvtest::TS::ptr()->get_rng();
-    Size size(200 + cvtest::randInt(rng) % 1000,
-              200 + cvtest::randInt(rng) % 1000);
-    for (int cn = 1; cn <= 4; ++cn)
-    {
-        Mat img1 = cvtest::randomMat(rng, size, CV_MAKE_TYPE(CV_8U, cn), 0, 255, false);
-        Mat img2 = cvtest::randomMat(rng, size, CV_MAKE_TYPE(CV_8U, cn), 0, 255, false);
-        Mat weights1 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
-        Mat weights2 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
-        Mat result_gold(size, CV_MAKE_TYPE(CV_8U, cn));
-        for (int y = 0; y < size.height; ++y)
-            for (int x = 0; x < size.width * cn; ++x)
-            {
-                float w1 = weights1.at<float>(y, x / cn);
-                float w2 = weights2.at<float>(y, x / cn);
-                result_gold.at<uchar>(y, x) = static_cast<uchar>(
-                    (img1.at<uchar>(y, x) * w1 + img2.at<uchar>(y, x) * w2) / (w1 + w2 + 1e-5f));
-            }
-        GpuMat d_result;
-        blendLinear(GpuMat(img1), GpuMat(img2), GpuMat(weights1), GpuMat(weights2), d_result);
-        ASSERT_LE(cvtest::norm(result_gold, Mat(d_result), NORM_INF), 1) 
-            << "rows=" << size.height << ", cols=" << size.width << ", cn=" << cn;
-    }
-}
-
-TEST(blendLinear, accuracy_on_32F)
-{
-    RNG& rng = cvtest::TS::ptr()->get_rng();
-    Size size(200 + cvtest::randInt(rng) % 1000,
-              200 + cvtest::randInt(rng) % 1000);
-    for (int cn = 1; cn <= 4; ++cn)
-    {
-        Mat img1 = cvtest::randomMat(rng, size, CV_MAKE_TYPE(CV_32F, cn), 0, 1, false);
-        Mat img2 = cvtest::randomMat(rng, size, CV_MAKE_TYPE(CV_32F, cn), 0, 1, false);
-        Mat weights1 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
-        Mat weights2 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
-        Mat result_gold(size, CV_MAKE_TYPE(CV_32F, cn));
-        for (int y = 0; y < size.height; ++y)
-            for (int x = 0; x < size.width * cn; ++x)
-            {
-                float w1 = weights1.at<float>(y, x / cn);
-                float w2 = weights2.at<float>(y, x / cn);
-                result_gold.at<float>(y, x) = 
-                    (img1.at<float>(y, x) * w1 + img2.at<float>(y, x) * w2) / (w1 + w2 + 1e-5f);
-            }
-        GpuMat d_result;
-        blendLinear(GpuMat(img1), GpuMat(img2), GpuMat(weights1), GpuMat(weights2), d_result);
-        ASSERT_LE(cvtest::norm(result_gold, Mat(d_result), NORM_INF), 1e-3)
-            << "rows=" << size.height << ", cols=" << size.width << ", cn=" << cn;
-    }
-}
diff --git a/modules/gpu/test/test_brute_force_matcher.cpp b/modules/gpu/test/test_brute_force_matcher.cpp
deleted file mode 100644
index 59af9f04f9..0000000000
--- a/modules/gpu/test/test_brute_force_matcher.cpp
+++ /dev/null
@@ -1,522 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-#include <algorithm>
-#include <iterator>
-
-using namespace cv;
-using namespace cv::gpu;
-using namespace std;
-
-class CV_GpuBruteForceMatcherTest : public cvtest::BaseTest
-{
-public:
-    CV_GpuBruteForceMatcherTest()
-    {
-    }
-
-protected:
-    virtual void run(int);
-    
-    void emptyDataTest();
-    void dataTest(int dim);
-    
-    void generateData(GpuMat& query, GpuMat& train, int dim);
-
-    void matchTest(const GpuMat& query, const GpuMat& train);
-    void knnMatchTest(const GpuMat& query, const GpuMat& train);
-    void radiusMatchTest(const GpuMat& query, const GpuMat& train);
-
-private:
-    BruteForceMatcher_GPU< L2<float> > dmatcher;
-
-    static const int queryDescCount = 300; // must be even number because we split train data in some cases in two
-    static const int countFactor = 4; // do not change it
-};
-
-void CV_GpuBruteForceMatcherTest::emptyDataTest()
-{
-    GpuMat queryDescriptors, trainDescriptors, mask;
-    vector<GpuMat> trainDescriptorCollection, masks;
-    vector<DMatch> matches;
-    vector< vector<DMatch> > vmatches;
-
-    try
-    {
-        dmatcher.match(queryDescriptors, trainDescriptors, matches, mask);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "match() on empty descriptors must not generate exception (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.knnMatch(queryDescriptors, trainDescriptors, vmatches, 2, mask);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "knnMatch() on empty descriptors must not generate exception (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.radiusMatch(queryDescriptors, trainDescriptors, vmatches, 10.f, mask);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "radiusMatch() on empty descriptors must not generate exception (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.add(trainDescriptorCollection);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "add() on empty descriptors must not generate exception.\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.match(queryDescriptors, matches, masks);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "match() on empty descriptors must not generate exception (2).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.knnMatch(queryDescriptors, vmatches, 2, masks);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "knnMatch() on empty descriptors must not generate exception (2).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-    try
-    {
-        dmatcher.radiusMatch( queryDescriptors, vmatches, 10.f, masks );
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "radiusMatch() on empty descriptors must not generate exception (2).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
-
-}
-
-void CV_GpuBruteForceMatcherTest::generateData( GpuMat& queryGPU, GpuMat& trainGPU, int dim )
-{
-    Mat query, train;
-    RNG& rng = ts->get_rng();
-
-    // Generate query descriptors randomly.
-    // Descriptor vector elements are integer values.
-    Mat buf( queryDescCount, dim, CV_32SC1 );
-    rng.fill( buf, RNG::UNIFORM, Scalar::all(0), Scalar(3) );
-    buf.convertTo( query, CV_32FC1 );
-
-    // Generate train decriptors as follows:
-    // copy each query descriptor to train set countFactor times
-    // and perturb some one element of the copied descriptors in
-    // in ascending order. General boundaries of the perturbation
-    // are (0.f, 1.f).
-    train.create( query.rows*countFactor, query.cols, CV_32FC1 );
-    float step = 1.f / countFactor;
-    for( int qIdx = 0; qIdx < query.rows; qIdx++ )
-    {
-        Mat queryDescriptor = query.row(qIdx);
-        for( int c = 0; c < countFactor; c++ )
-        {
-            int tIdx = qIdx * countFactor + c;
-            Mat trainDescriptor = train.row(tIdx);
-            queryDescriptor.copyTo( trainDescriptor );
-            int elem = rng(dim);
-            float diff = rng.uniform( step*c, step*(c+1) );
-            trainDescriptor.at<float>(0, elem) += diff;
-        }
-    }
-
-    queryGPU.upload(query);
-    trainGPU.upload(train);
-}
-
-void CV_GpuBruteForceMatcherTest::matchTest( const GpuMat& query, const GpuMat& train )
-{
-    dmatcher.clear();
-
-    // test const version of match()
-    {
-        vector<DMatch> matches;
-        dmatcher.match( query, train, matches );
-
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test match() function (1).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-        else
-        {
-            int badCount = 0;
-            for( size_t i = 0; i < matches.size(); i++ )
-            {
-                DMatch match = matches[i];
-                if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0) )
-                    badCount++;
-            }
-            if (badCount > 0)
-            {
-                ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test match() function (1).\n",
-                            (float)badCount/(float)queryDescCount );
-                ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-            }
-        }
-    }
-
-    // test version of match() with add()
-    {
-        vector<DMatch> matches;
-        // make add() twice to test such case
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(0, train.rows/2)) );
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(train.rows/2, train.rows)) );
-        // prepare masks (make first nearest match illegal)
-        vector<GpuMat> masks(2);
-        for(int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = GpuMat(query.rows, train.rows/2, CV_8UC1, Scalar::all(1));
-            for( int di = 0; di < queryDescCount/2; di++ )
-                masks[mi].col(di*countFactor).setTo(Scalar::all(0));
-        }
-
-        dmatcher.match( query, matches, masks );
-
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test match() function (2).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-        else
-        {
-            int badCount = 0;
-            for( size_t i = 0; i < matches.size(); i++ )
-            {
-                DMatch match = matches[i];
-                int shift = dmatcher.isMaskSupported() ? 1 : 0;
-                {
-                    if( i < queryDescCount/2 )
-                    {
-                        if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor + shift) || (match.imgIdx != 0) )
-                            badCount++;
-                    }
-                    else
-                    {
-                        if( (match.queryIdx != (int)i) || (match.trainIdx != ((int)i-queryDescCount/2)*countFactor + shift) || (match.imgIdx != 1) )
-                            badCount++;
-                    }
-                }
-            }
-            if (badCount > 0)
-            {
-                ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test match() function (2).\n",
-                            (float)badCount/(float)queryDescCount );
-                ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
-            }
-        }
-    }
-}
-
-void CV_GpuBruteForceMatcherTest::knnMatchTest( const GpuMat& query, const GpuMat& train )
-{
-    dmatcher.clear();
-
-    // test const version of knnMatch()
-    {
-        const int knn = 3;
-
-        vector< vector<DMatch> > matches;
-        dmatcher.knnMatch( query, train, matches, knn );
-
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test knnMatch() function (1).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-        else
-        {
-            int badCount = 0;
-            for( size_t i = 0; i < matches.size(); i++ )
-            {
-                if( (int)matches[i].size() != knn )
-                    badCount++;
-                else
-                {
-                    int localBadCount = 0;
-                    for( int k = 0; k < knn; k++ )
-                    {
-                        DMatch match = matches[i][k];
-                        if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor+k) || (match.imgIdx != 0) )
-                            localBadCount++;
-                    }
-                    badCount += localBadCount > 0 ? 1 : 0;
-                }
-            }
-            if (badCount > 0)
-            {
-                ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test knnMatch() function (1).\n",
-                            (float)badCount/(float)queryDescCount );
-                ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-            }
-        }
-    }
-
-    // test version of knnMatch() with add()
-    {
-        const int knn = 2;
-        vector<vector<DMatch> > matches;
-        // make add() twice to test such case
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(0, train.rows/2)) );
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(train.rows/2, train.rows)) );
-        // prepare masks (make first nearest match illegal)
-        vector<GpuMat> masks(2);
-        for(int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = GpuMat(query.rows, train.rows/2, CV_8UC1, Scalar::all(1));
-            for( int di = 0; di < queryDescCount/2; di++ )
-                masks[mi].col(di*countFactor).setTo(Scalar::all(0));
-        }
-
-        dmatcher.knnMatch( query, matches, knn, masks );
-
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test knnMatch() function (2).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-        else
-        {
-            int badCount = 0;
-            int shift = dmatcher.isMaskSupported() ? 1 : 0;
-            for( size_t i = 0; i < matches.size(); i++ )
-            {
-                if( (int)matches[i].size() != knn )
-                    badCount++;
-                else
-                {
-                    int localBadCount = 0;
-                    for( int k = 0; k < knn; k++ )
-                    {
-                        DMatch match = matches[i][k];
-                        {
-                            if( i < queryDescCount/2 )
-                            {
-                                if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor + k + shift) ||
-                                    (match.imgIdx != 0) )
-                                    localBadCount++;
-                            }
-                            else
-                            {
-                                if( (match.queryIdx != (int)i) || (match.trainIdx != ((int)i-queryDescCount/2)*countFactor + k + shift) ||
-                                    (match.imgIdx != 1) )
-                                    localBadCount++;
-                            }
-                        }
-                    }
-                    badCount += localBadCount > 0 ? 1 : 0;
-                }
-            }
-            if (badCount > 0)
-            {
-                ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test knnMatch() function (2).\n",
-                            (float)badCount/(float)queryDescCount );
-                ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
-            }
-        }
-    }
-}
-
-void CV_GpuBruteForceMatcherTest::radiusMatchTest( const GpuMat& query, const GpuMat& train )
-{
-    bool atomics_ok = TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS);
-    if (!atomics_ok)
-    {
-        ts->printf(cvtest::TS::CONSOLE, "\nCode and device atomics support is required for radiusMatch (CC >= 1.1)");
-        ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-        return;
-    }
-
-    dmatcher.clear();
-    // test const version of match()
-    {
-        const float radius = 1.f/countFactor;
-        vector< vector<DMatch> > matches;
-        dmatcher.radiusMatch( query, train, matches, radius );
-
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test radiusMatch() function (1).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-        else
-        {
-            int badCount = 0;
-            for( size_t i = 0; i < matches.size(); i++ )
-            {
-                if( (int)matches[i].size() != 1 )
-                    badCount++;
-                else
-                {
-                    DMatch match = matches[i][0];
-                    if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0) )
-                        badCount++;
-                }
-            }
-            if (badCount > 0)
-            {
-                ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test radiusMatch() function (1).\n",
-                            (float)badCount/(float)queryDescCount );
-                ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-            }
-        }
-    }
-
-    // test version of match() with add()
-    {
-        int n = 3;
-        const float radius = 1.f/countFactor * n;
-        vector< vector<DMatch> > matches;
-        // make add() twice to test such case
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(0, train.rows/2)) );
-        dmatcher.add( vector<GpuMat>(1,train.rowRange(train.rows/2, train.rows)) );
-        // prepare masks (make first nearest match illegal)
-        vector<GpuMat> masks(2);
-        for(int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = GpuMat(query.rows, train.rows/2, CV_8UC1, Scalar::all(1));
-            for( int di = 0; di < queryDescCount/2; di++ )
-                masks[mi].col(di*countFactor).setTo(Scalar::all(0));
-        }
-
-        dmatcher.radiusMatch( query, matches, radius, masks );
-
-        int curRes = cvtest::TS::OK;
-        if( (int)matches.size() != queryDescCount )
-        {
-            ts->printf(cvtest::TS::LOG, "Incorrect matches count while test radiusMatch() function (1).\n");
-            ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        }
-
-        int badCount = 0;
-        int shift = dmatcher.isMaskSupported() ? 1 : 0;
-        int needMatchCount = dmatcher.isMaskSupported() ? n-1 : n;
-        for( size_t i = 0; i < matches.size(); i++ )
-        {
-            if( (int)matches[i].size() != needMatchCount )
-                badCount++;
-            else
-            {
-                int localBadCount = 0;
-                for( int k = 0; k < needMatchCount; k++ )
-                {
-                    DMatch match = matches[i][k];
-                    {
-                        if( i < queryDescCount/2 )
-                        {
-                            if( (match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor + k + shift) ||
-                                (match.imgIdx != 0) )
-                                localBadCount++;
-                        }
-                        else
-                        {
-                            if( (match.queryIdx != (int)i) || (match.trainIdx != ((int)i-queryDescCount/2)*countFactor + k + shift) ||
-                                (match.imgIdx != 1) )
-                                localBadCount++;
-                        }
-                    }
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
-            }
-        }
-
-        if (badCount > 0)
-        {
-            curRes = cvtest::TS::FAIL_INVALID_OUTPUT;
-            ts->printf( cvtest::TS::LOG, "%f - too large bad matches part while test radiusMatch() function (2).\n",
-                        (float)badCount/(float)queryDescCount );
-            ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
-        }
-    }
-}
-
-void CV_GpuBruteForceMatcherTest::dataTest(int dim)
-{
-    GpuMat query, train;
-    generateData(query, train, dim);
-
-    matchTest(query, train);
-    knnMatchTest(query, train);
-    radiusMatchTest(query, train);
-
-    dmatcher.clear();
-}
-
-void CV_GpuBruteForceMatcherTest::run(int)
-{
-    emptyDataTest();
-
-    dataTest(50);
-    dataTest(64);
-    dataTest(100);
-    dataTest(128);
-    dataTest(200);
-    dataTest(256);
-    dataTest(300);
-}
-
-TEST(BruteForceMatcher, accuracy) { CV_GpuBruteForceMatcherTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp
index 3fdcf47d83..d6fe168c3b 100644
--- a/modules/gpu/test/test_calib3d.cpp
+++ b/modules/gpu/test/test_calib3d.cpp
@@ -1,135 +1,379 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace cv::gpu;
-using namespace cvtest;
-
-TEST(projectPoints, accuracy)
-{
-    RNG& rng = TS::ptr()->get_rng();
-    Mat src = randomMat(rng, Size(1000, 1), CV_32FC3, 0, 10, false);
-    Mat rvec = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-    Mat tvec = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-    Mat camera_mat = randomMat(rng, Size(3, 3), CV_32F, 0, 1, false);
-    camera_mat.at<float>(0, 1) = 0.f;
-    camera_mat.at<float>(1, 0) = 0.f;
-    camera_mat.at<float>(2, 0) = 0.f;
-    camera_mat.at<float>(2, 1) = 0.f;
-
-    vector<Point2f> dst;
-    projectPoints(src, rvec, tvec, camera_mat, Mat(1, 8, CV_32F, Scalar::all(0)), dst);
-
-    GpuMat d_dst;
-    projectPoints(GpuMat(src), rvec, tvec, camera_mat, Mat(), d_dst);
-
-    ASSERT_EQ(dst.size(), (size_t)d_dst.cols);
-    ASSERT_EQ(1, d_dst.rows);
-    ASSERT_EQ(CV_32FC2, d_dst.type());
-
-    Mat h_dst(d_dst);
-    for (size_t i = 0; i < dst.size(); ++i)
-    {
-        Point2f res_gold = dst[i];
-        Point2f res_actual = h_dst.at<Point2f>(0, i);
-        Point2f err = res_actual - res_gold;
-        ASSERT_LT(err.dot(err) / res_gold.dot(res_gold), 1e-3f);
-    }
-}
-
-
-TEST(transformPoints, accuracy)
-{
-    RNG& rng = TS::ptr()->get_rng();
-    Mat src = randomMat(rng, Size(1000, 1), CV_32FC3, 0, 10, false);
-    Mat rvec = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-    Mat tvec = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-
-    GpuMat d_dst;
-    transformPoints(GpuMat(src), rvec, tvec, d_dst);
-    ASSERT_TRUE(src.size() == d_dst.size());
-    ASSERT_EQ(src.type(), d_dst.type());
-
-    Mat h_dst(d_dst);
-    Mat rot;
-    Rodrigues(rvec, rot);
-    for (int i = 0; i < h_dst.cols; ++i)
-    {
-        Point3f p = src.at<Point3f>(0, i);
-        Point3f res_gold(
-                rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
-                rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
-                rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
-        Point3f res_actual = h_dst.at<Point3f>(0, i);
-        Point3f err = res_actual - res_gold;
-        ASSERT_LT(err.dot(err) / res_gold.dot(res_gold), 1e-3f);
-    }
-}
-
-
-TEST(solvePnPRansac, accuracy)
-{
-    RNG& rng = TS::ptr()->get_rng();
-
-    const int num_points = 5000;
-    Mat object = randomMat(rng, Size(num_points, 1), CV_32FC3, 0, 100, false);
-    Mat camera_mat = randomMat(rng, Size(3, 3), CV_32F, 0.5, 1, false);
-    camera_mat.at<float>(0, 1) = 0.f;
-    camera_mat.at<float>(1, 0) = 0.f;
-    camera_mat.at<float>(2, 0) = 0.f;
-    camera_mat.at<float>(2, 1) = 0.f;
-
-    Mat rvec_gold = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-    Mat tvec_gold = randomMat(rng, Size(3, 1), CV_32F, 0, 1, false);
-
-    vector<Point2f> image_vec;
-    projectPoints(object, rvec_gold, tvec_gold, camera_mat, Mat(1, 8, CV_32F, Scalar::all(0)), image_vec);
-    Mat image(1, image_vec.size(), CV_32FC2, &image_vec[0]);
-
-    Mat rvec, tvec;
-    vector<int> inliers;
-    gpu::solvePnPRansac(object, image, camera_mat, Mat(1, 8, CV_32F, Scalar::all(0)), rvec, tvec, false, 200, 2.f, 100, &inliers);
-
-    ASSERT_LE(norm(rvec - rvec_gold), 1e-3f);
-    ASSERT_LE(norm(tvec - tvec_gold), 1e-3f);
-}
+/*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*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+//////////////////////////////////////////////////////////////////////////
+// BlockMatching
+
+struct StereoBlockMatching : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::Mat img_l;
+    cv::Mat img_r;
+    cv::Mat img_template;
+    
+    cv::gpu::DeviceInfo devInfo;    
+    
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        img_l = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);
+        img_r = readImage("stereobm/aloe-R.png", CV_LOAD_IMAGE_GRAYSCALE);
+        img_template = readImage("stereobm/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE);
+        
+        ASSERT_FALSE(img_l.empty());
+        ASSERT_FALSE(img_r.empty());
+        ASSERT_FALSE(img_template.empty());
+    }
+};
+
+TEST_P(StereoBlockMatching, Regression) 
+{
+    PRINT_PARAM(devInfo);
+    
+    cv::Mat disp;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_disp;
+        cv::gpu::StereoBM_GPU bm(0, 128, 19);
+
+        bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+        
+        dev_disp.download(disp);
+    );
+
+    disp.convertTo(disp, img_template.type());
+    
+    EXPECT_MAT_NEAR(img_template, disp, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoBlockMatching, testing::ValuesIn(devices()));
+
+//////////////////////////////////////////////////////////////////////////
+// BeliefPropagation
+
+struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::Mat img_l;
+    cv::Mat img_r;
+    cv::Mat img_template;
+    
+    cv::gpu::DeviceInfo devInfo;  
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+           
+        img_l = readImage("stereobp/aloe-L.png");
+        img_r = readImage("stereobp/aloe-R.png");
+        img_template = readImage("stereobp/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE);
+        
+        ASSERT_FALSE(img_l.empty());
+        ASSERT_FALSE(img_r.empty());
+        ASSERT_FALSE(img_template.empty());
+    }
+};
+
+TEST_P(StereoBeliefPropagation, Regression) 
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat disp;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_disp;
+        cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+
+        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+        
+        dev_disp.download(disp);
+    );
+
+    disp.convertTo(disp, img_template.type());
+    
+    EXPECT_MAT_NEAR(img_template, disp, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoBeliefPropagation, testing::ValuesIn(devices()));
+
+//////////////////////////////////////////////////////////////////////////
+// ConstantSpaceBP
+
+struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::Mat img_l;
+    cv::Mat img_r;
+    cv::Mat img_template;
+    
+    cv::gpu::DeviceInfo devInfo;
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        img_l = readImage("csstereobp/aloe-L.png");
+        img_r = readImage("csstereobp/aloe-R.png");
+
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            img_template = readImage("csstereobp/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE);
+        else
+            img_template = readImage("csstereobp/aloe-disp_CC1X.png", CV_LOAD_IMAGE_GRAYSCALE);
+            
+        ASSERT_FALSE(img_l.empty());
+        ASSERT_FALSE(img_r.empty());
+        ASSERT_FALSE(img_template.empty());        
+    }
+};
+
+TEST_P(StereoConstantSpaceBP, Regression) 
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat disp;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_disp;
+        cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
+
+        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), dev_disp);
+        
+        dev_disp.download(disp);
+    );
+
+    disp.convertTo(disp, img_template.type());
+    
+    EXPECT_MAT_NEAR(img_template, disp, 1.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, StereoConstantSpaceBP, testing::ValuesIn(devices()));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// projectPoints
+
+struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat src;
+    cv::Mat rvec;
+    cv::Mat tvec;
+    cv::Mat camera_mat;
+    
+    std::vector<cv::Point2f> dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        src = cvtest::randomMat(rng, cv::Size(1000, 1), CV_32FC3, 0, 10, false);
+        rvec = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+        tvec = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+        camera_mat = cvtest::randomMat(rng, cv::Size(3, 3), CV_32F, 0, 1, false);
+        camera_mat.at<float>(0, 1) = 0.f;
+        camera_mat.at<float>(1, 0) = 0.f;
+        camera_mat.at<float>(2, 0) = 0.f;
+        camera_mat.at<float>(2, 1) = 0.f;
+
+        cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
+    }
+};
+
+TEST_P(ProjectPoints, Accuracy) 
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(   
+        cv::gpu::GpuMat d_dst;
+
+        cv::gpu::projectPoints(cv::gpu::GpuMat(src), rvec, tvec, camera_mat, cv::Mat(), d_dst);
+
+        d_dst.download(dst);
+    );
+
+    ASSERT_EQ(dst_gold.size(), dst.cols);
+    ASSERT_EQ(1, dst.rows);
+    ASSERT_EQ(CV_32FC2, dst.type());
+
+    for (size_t i = 0; i < dst_gold.size(); ++i)
+    {
+        cv::Point2f res_gold = dst_gold[i];
+        cv::Point2f res_actual = dst.at<cv::Point2f>(0, i);
+        cv::Point2f err = res_actual - res_gold;
+
+        ASSERT_LE(err.dot(err) / res_gold.dot(res_gold), 1e-3f);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, ProjectPoints, testing::ValuesIn(devices()));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// transformPoints
+
+struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Mat src;
+    cv::Mat rvec;
+    cv::Mat tvec;
+    cv::Mat rot;
+        
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        src = cvtest::randomMat(rng, cv::Size(1000, 1), CV_32FC3, 0, 10, false);
+        rvec = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+        tvec = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+
+        cv::Rodrigues(rvec, rot);
+    }
+};
+
+TEST_P(TransformPoints, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_dst;
+
+        cv::gpu::transformPoints(cv::gpu::GpuMat(src), rvec, tvec, d_dst);
+
+        d_dst.download(dst);
+    );
+    
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(src.type(), dst.type());
+
+    for (int i = 0; i < dst.cols; ++i)
+    {
+        cv::Point3f p = src.at<cv::Point3f>(0, i);
+        cv::Point3f res_gold(
+                rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
+                rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
+                rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
+        cv::Point3f res_actual = dst.at<cv::Point3f>(0, i);
+        cv::Point3f err = res_actual - res_gold;
+
+        ASSERT_LE(err.dot(err) / res_gold.dot(res_gold), 1e-3f);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, TransformPoints, testing::ValuesIn(devices()));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// solvePnPRansac
+
+struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    static const int num_points = 5000;
+
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Mat object;
+    cv::Mat camera_mat;
+    std::vector<cv::Point2f> image_vec;
+
+    cv::Mat rvec_gold;
+    cv::Mat tvec_gold;
+        
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        object = cvtest::randomMat(rng, cv::Size(num_points, 1), CV_32FC3, 0, 100, false);
+        camera_mat = cvtest::randomMat(rng, cv::Size(3, 3), CV_32F, 0.5, 1, false);
+        camera_mat.at<float>(0, 1) = 0.f;
+        camera_mat.at<float>(1, 0) = 0.f;
+        camera_mat.at<float>(2, 0) = 0.f;
+        camera_mat.at<float>(2, 1) = 0.f;
+
+        rvec_gold = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+        tvec_gold = cvtest::randomMat(rng, cv::Size(3, 1), CV_32F, 0, 1, false);
+
+        cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
+    }
+};
+
+TEST_P(SolvePnPRansac, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat rvec, tvec;
+    std::vector<int> inliers;
+
+    ASSERT_NO_THROW(
+        cv::gpu::solvePnPRansac(object, cv::Mat(1, image_vec.size(), CV_32FC2, &image_vec[0]), camera_mat, 
+                                cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), rvec, tvec, false, 200, 2.f, 100, &inliers);
+    );
+
+    ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3f);
+    ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3f);
+}
+
+INSTANTIATE_TEST_CASE_P(Calib3D, SolvePnPRansac, testing::ValuesIn(devices()));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_dft_routines.cpp b/modules/gpu/test/test_dft_routines.cpp
deleted file mode 100644
index f346bef428..0000000000
--- a/modules/gpu/test/test_dft_routines.cpp
+++ /dev/null
@@ -1,399 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace cv::gpu;
-using namespace std;
-
-struct CV_GpuMulSpectrumsTest: cvtest::BaseTest
-{
-    CV_GpuMulSpectrumsTest() {}
-
-    void run(int)
-    {
-        test(0);
-        testConj(0);
-        testScaled(0);
-        testScaledConj(0);
-        test(DFT_ROWS);
-        testConj(DFT_ROWS);
-        testScaled(DFT_ROWS);
-        testScaledConj(DFT_ROWS);
-    }
-
-    void gen(int cols, int rows, Mat& mat)
-    {
-        RNG rng;
-        mat.create(rows, cols, CV_32FC2);
-        rng.fill(mat, RNG::UNIFORM, Scalar::all(0.f), Scalar::all(10.f));
-    }
-
-    bool cmp(const Mat& gold, const Mat& mine, float max_err=1e-3f)
-    {
-        if (gold.size() != mine.size())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad sizes: gold: %d d%, mine: %d %d\n", gold.cols, gold.rows, mine.cols, mine.rows);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        if (gold.type() != mine.type())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad types: gold=%d, mine=%d\n", gold.type(), mine.type());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        for (int i = 0; i < gold.rows; ++i)
-        {
-            for (int j = 0; j < gold.cols * 2; ++j)
-            {
-                float gold_ = gold.at<float>(i, j);
-                float mine_ = mine.at<float>(i, j);
-                if (fabs(gold_ - mine_) > max_err)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "bad values at %d %d: gold=%f, mine=%f\n", j, i, gold_, mine_);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    bool cmpScaled(const Mat& gold, const Mat& mine, float scale, float max_err=1e-3f)
-    {
-        if (gold.size() != mine.size())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad sizes: gold: %d d%, mine: %d %d\n", gold.cols, gold.rows, mine.cols, mine.rows);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        if (gold.type() != mine.type())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad types: gold=%d, mine=%d\n", gold.type(), mine.type());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        for (int i = 0; i < gold.rows; ++i)
-        {
-            for (int j = 0; j < gold.cols * 2; ++j)
-            {
-                float gold_ = gold.at<float>(i, j) * scale;
-                float mine_ = mine.at<float>(i, j);
-                if (fabs(gold_ - mine_) > max_err)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "bad values at %d %d: gold=%f, mine=%f\n", j, i, gold_, mine_);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    void test(int flags)
-    {
-        int cols = 1 + rand() % 100, rows = 1 + rand() % 1000;
-
-        Mat a, b;
-        gen(cols, rows, a);
-        gen(cols, rows, b);
-
-        Mat c_gold;
-        mulSpectrums(a, b, c_gold, flags, false);
-
-        GpuMat d_c;
-        mulSpectrums(GpuMat(a), GpuMat(b), d_c, flags, false);
-
-        if (!cmp(c_gold, Mat(d_c)))
-            ts->printf(cvtest::TS::CONSOLE, "test failed: cols=%d, rows=%d, flags=%d\n", cols, rows, flags);
-    }
-
-    void testConj(int flags)
-    {
-        int cols = 1 + rand() % 100, rows = 1 + rand() % 1000;
-
-        Mat a, b;
-        gen(cols, rows, a);
-        gen(cols, rows, b);
-
-        Mat c_gold;
-        mulSpectrums(a, b, c_gold, flags, true);
-
-        GpuMat d_c;
-        mulSpectrums(GpuMat(a), GpuMat(b), d_c, flags, true);
-
-        if (!cmp(c_gold, Mat(d_c)))
-            ts->printf(cvtest::TS::CONSOLE, "testConj failed: cols=%d, rows=%d, flags=%d\n", cols, rows, flags);
-    }
-
-    void testScaled(int flags)
-    {
-        int cols = 1 + rand() % 100, rows = 1 + rand() % 1000;
-
-        Mat a, b;
-        gen(cols, rows, a);
-        gen(cols, rows, b);
-        float scale = 1.f / a.size().area();
-
-        Mat c_gold;
-        mulSpectrums(a, b, c_gold, flags, false);
-
-        GpuMat d_c;
-        mulAndScaleSpectrums(GpuMat(a), GpuMat(b), d_c, flags, scale, false);
-
-        if (!cmpScaled(c_gold, Mat(d_c), scale))
-            ts->printf(cvtest::TS::CONSOLE, "testScaled failed: cols=%d, rows=%d, flags=%d\n", cols, rows, flags);
-    }
-
-    void testScaledConj(int flags)
-    {
-        int cols = 1 + rand() % 100, rows = 1 + rand() % 1000;
-
-        Mat a, b;
-        gen(cols, rows, a);
-        gen(cols, rows, b);
-        float scale = 1.f / a.size().area();
-
-        Mat c_gold;
-        mulSpectrums(a, b, c_gold, flags, true);
-
-        GpuMat d_c;
-        mulAndScaleSpectrums(GpuMat(a), GpuMat(b), d_c, flags, scale, true);
-
-        if (!cmpScaled(c_gold, Mat(d_c), scale))
-            ts->printf(cvtest::TS::CONSOLE, "testScaledConj failed: cols=%d, rows=%d, flags=%D\n", cols, rows, flags);
-    }
-} CV_GpuMulSpectrumsTest_inst;
-
-
-struct CV_GpuDftTest: cvtest::BaseTest
-{
-    CV_GpuDftTest() {}
-
-    void run(int)
-    {
-        srand(0);
-        int cols = 2 + rand() % 100, rows = 2 + rand() % 100;
-
-        for (int i = 0; i < 2; ++i)
-        {
-            bool inplace = i != 0;
-            testC2C("no flags", cols, rows, 0, inplace);
-            testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
-            testC2C("DFT_INVERSE", cols, rows, DFT_INVERSE, inplace);
-            testC2C("DFT_ROWS", cols, rows, DFT_ROWS, inplace);
-            testC2C("single col", 1, rows, 0, inplace);
-            testC2C("single row", cols, 1, 0, inplace);
-            testC2C("single col inversed", 1, rows, DFT_INVERSE, inplace);
-            testC2C("single row inversed", cols, 1, DFT_INVERSE, inplace);
-            testC2C("single row DFT_ROWS", cols, 1, DFT_ROWS, inplace);
-            testC2C("size 1 2", 1, 2, 0, inplace);
-            testC2C("size 2 1", 2, 1, 0, inplace);
-        }
-
-        testR2CThenC2R("sanity", cols, rows);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1);
-        testR2CThenC2R("single col", 1, rows);
-        testR2CThenC2R("single col 1", 1, rows + 1);
-        testR2CThenC2R("single row", cols, 1);
-        testR2CThenC2R("single row 1", cols + 1, 1);
-
-        testR2CThenC2R("sanity", cols, rows, true);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
-        testR2CThenC2R("single row", cols, 1, true);
-        testR2CThenC2R("single row 1", cols + 1, 1, true);
-}
-
-    void gen(int cols, int rows, int cn, Mat& mat)
-    {
-        RNG rng(1);
-        mat.create(rows, cols, CV_MAKETYPE(CV_32F, cn));
-        rng.fill(mat, RNG::UNIFORM, Scalar::all(0.f), Scalar::all(10.f));
-    }
-
-    bool cmp(const Mat& gold, const Mat& mine, float max_err=1e-3f)
-    {
-        if (gold.size() != mine.size())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad sizes: gold: %d %d, mine: %d %d\n", gold.cols, gold.rows, mine.cols, mine.rows);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        if (gold.depth() != mine.depth())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad depth: gold=%d, mine=%d\n", gold.depth(), mine.depth());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        if (gold.channels() != mine.channels())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad channel count: gold=%d, mine=%d\n", gold.channels(), mine.channels());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-        for (int i = 0; i < gold.rows; ++i)
-        {
-            for (int j = 0; j < gold.cols * gold.channels(); ++j)
-            {
-                float gold_ = gold.at<float>(i, j);
-                float mine_ = mine.at<float>(i, j);
-                if (fabs(gold_ - mine_) > max_err)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "bad values at %d %d: gold=%f, mine=%f\n", j / gold.channels(), i, gold_, mine_);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace=false)
-    {
-        Mat a;
-        gen(cols, rows, 2, a);
-
-        Mat b_gold;
-        dft(a, b_gold, flags);
-
-        GpuMat d_b;
-        GpuMat d_b_data;
-        if (inplace)
-        {
-            d_b_data.create(1, a.size().area(), CV_32FC2);
-            d_b = GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
-        }
-
-        dft(GpuMat(a), d_b, Size(cols, rows), flags);
-
-        bool ok = true;
-        if (ok && inplace && d_b.ptr() != d_b_data.ptr())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "unnecessary reallocation was done\n");
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok && d_b.depth() != CV_32F)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad depth: %d\n", d_b.depth());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok && d_b.channels() != 2)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad channel count: %d\n", d_b.channels());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok) ok = cmp(b_gold, Mat(d_b), rows * cols * 1e-4f);
-        if (!ok) 
-            ts->printf(cvtest::TS::CONSOLE, "testC2C failed: hint=%s, cols=%d, rows=%d, flags=%d, inplace=%d\n", 
-                       hint.c_str(), cols, rows, flags, inplace);
-    }
-
-    void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace=false)
-    {
-        Mat a;
-        gen(cols, rows, 1, a);
-
-        bool ok = true;
-
-        GpuMat d_b, d_c;
-        GpuMat d_b_data, d_c_data;
-        if (inplace)
-        {
-            if (a.cols == 1)
-            {
-                d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
-                d_b = GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
-            }
-            else
-            {
-                d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
-                d_b = GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
-            }
-            d_c_data.create(1, a.size().area(), CV_32F);
-            d_c = GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
-        }
-
-        dft(GpuMat(a), d_b, Size(cols, rows), 0);
-        dft(d_b, d_c, Size(cols, rows), DFT_REAL_OUTPUT | DFT_SCALE);
-
-        if (ok && inplace && d_b.ptr() != d_b_data.ptr())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "unnecessary reallocation was done for b\n");
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok && inplace && d_c.ptr() != d_c_data.ptr())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "unnecessary reallocation was done for c\n");
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok && d_c.depth() != CV_32F)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad depth: %d\n", d_c.depth());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok && d_c.channels() != 1)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad channel count: %d\n", d_c.channels());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            ok = false;
-        }
-        if (ok) ok = cmp(a, Mat(d_c), rows * cols * 1e-5f);
-        if (!ok) 
-            ts->printf(cvtest::TS::CONSOLE, "testR2CThenC2R failed: hint=%s, cols=%d, rows=%d, inplace=%d\n", 
-                       hint.c_str(), cols, rows, inplace);
-    }
-};
-
-TEST(dft, accuracy) { CV_GpuDftTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index 12f71965c9..516c0f5920 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -40,156 +40,506 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include <string>
 
-using namespace cv;
-using namespace cv::gpu;
-using namespace std;
+#ifdef HAVE_CUDA
 
-const string FEATURES2D_DIR = "features2d";
-const string IMAGE_FILENAME = "aloe.png";
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// SURF
 
-class CV_GPU_SURFTest : public cvtest::BaseTest
+struct SURF : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-public:
-    CV_GPU_SURFTest()
+    cv::Mat image;
+    cv::Mat mask;
+    std::vector<cv::KeyPoint> keypoints_gold;
+    std::vector<float> descriptors_gold;
+
+    cv::gpu::DeviceInfo devInfo;
+    
+    virtual void SetUp()
     {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        image = readImage("features2d/aloe.png", CV_LOAD_IMAGE_GRAYSCALE);
+        ASSERT_FALSE(image.empty());        
+        
+        mask = cv::Mat(image.size(), CV_8UC1, cv::Scalar::all(1));
+        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+                
+        cv::SURF fdetector_gold; fdetector_gold.extended = false;
+        fdetector_gold(image, mask, keypoints_gold, descriptors_gold);        
     }
 
-protected:
-    bool isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2);
-    int getValidCount(const vector<KeyPoint>& keypoints1, const vector<KeyPoint>& keypoints2, const vector<DMatch>& matches);
-    void compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints,
-                             const Mat& validDescriptors, const Mat& calcDescriptors);
+    bool isSimilarKeypoints(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
+    {
+        const float maxPtDif = 1.f;
+        const float maxSizeDif = 1.f;
+        const float maxAngleDif = 2.f;
+        const float maxResponseDif = 0.1f;
 
-    void emptyDataTest();
-    void accuracyTest();
-
-    virtual void run(int);
+        float dist = (float)cv::norm(p1.pt - p2.pt);
+        return (dist < maxPtDif &&
+                fabs(p1.size - p2.size) < maxSizeDif &&
+                abs(p1.angle - p2.angle) < maxAngleDif &&
+                abs(p1.response - p2.response) < maxResponseDif &&
+                p1.octave == p2.octave &&
+                p1.class_id == p2.class_id );
+    }
 };
 
-void CV_GPU_SURFTest::emptyDataTest()
+TEST_P(SURF, EmptyDataTest)
 {
-    SURF_GPU fdetector;
+    PRINT_PARAM(devInfo);
 
-    GpuMat image;
-    vector<KeyPoint> keypoints;
-    vector<float> descriptors;
-    try
-    {
-        fdetector(image, GpuMat(), keypoints, descriptors);
-    }
-    catch(...)
-    {
-        ts->printf( cvtest::TS::LOG, "detect() on empty image must not generate exception (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-    }
+    cv::gpu::SURF_GPU fdetector;
 
-    if( !keypoints.empty() )
-    {
-        ts->printf( cvtest::TS::LOG, "detect() on empty image must return empty keypoints vector (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        return;
-    }
+    cv::gpu::GpuMat image;
+    std::vector<cv::KeyPoint> keypoints;
+    std::vector<float> descriptors;
 
-    if( !descriptors.empty() )
-    {
-        ts->printf( cvtest::TS::LOG, "detect() on empty image must return empty descriptors vector (1).\n" );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
-        return;
-    }
+    ASSERT_NO_THROW(
+        fdetector(image, cv::gpu::GpuMat(), keypoints, descriptors);
+    );
+
+    EXPECT_TRUE(keypoints.empty());
+    EXPECT_TRUE(descriptors.empty());
 }
 
-bool CV_GPU_SURFTest::isSimilarKeypoints(const KeyPoint& p1, const KeyPoint& p2)
+TEST_P(SURF, Accuracy)
 {
-    const float maxPtDif = 1.f;
-    const float maxSizeDif = 1.f;
-    const float maxAngleDif = 2.f;
-    const float maxResponseDif = 0.1f;
+    PRINT_PARAM(devInfo);
 
-    float dist = (float)norm( p1.pt - p2.pt );
-    return (dist < maxPtDif &&
+    // Compute keypoints.
+    std::vector<cv::KeyPoint> keypoints;
+    cv::Mat descriptors;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_descriptors;
+        cv::gpu::SURF_GPU fdetector; fdetector.extended = false;
+
+        fdetector(cv::gpu::GpuMat(image), cv::gpu::GpuMat(mask), keypoints, dev_descriptors);
+
+        dev_descriptors.download(descriptors);
+    );
+
+    cv::BruteForceMatcher< cv::L2<float> > matcher;
+    std::vector<cv::DMatch> matches;
+
+    matcher.match(cv::Mat(static_cast<int>(keypoints_gold.size()), 64, CV_32FC1, &descriptors_gold[0]), descriptors, matches);
+
+    int validCount = 0;
+    
+    for (size_t i = 0; i < matches.size(); ++i)
+    {
+        const cv::DMatch& m = matches[i];
+
+        const cv::KeyPoint& p1 = keypoints_gold[m.queryIdx];
+        const cv::KeyPoint& p2 = keypoints[m.trainIdx];
+
+        const float maxPtDif = 1.f;
+        const float maxSizeDif = 1.f;
+        const float maxAngleDif = 2.f;
+        const float maxResponseDif = 0.1f;
+
+        float dist = (float)cv::norm(p1.pt - p2.pt);
+        if (dist < maxPtDif &&
             fabs(p1.size - p2.size) < maxSizeDif &&
             abs(p1.angle - p2.angle) < maxAngleDif &&
             abs(p1.response - p2.response) < maxResponseDif &&
             p1.octave == p2.octave &&
-            p1.class_id == p2.class_id );
-}
-
-int CV_GPU_SURFTest::getValidCount(const vector<KeyPoint>& keypoints1, const vector<KeyPoint>& keypoints2,
-                     const vector<DMatch>& matches)
-{
-    int count = 0;
-
-    for (size_t i = 0; i < matches.size(); ++i)
-    {
-        const DMatch& m = matches[i];
-
-        const KeyPoint& kp1 = keypoints1[m.queryIdx];
-        const KeyPoint& kp2 = keypoints2[m.trainIdx];
-
-        if (isSimilarKeypoints(kp1, kp2))
-            ++count;
+            p1.class_id == p2.class_id)
+        {
+            ++validCount;
+        }
     }
 
-    return count;
+    double validRatio = (double)validCount / matches.size();
+
+    EXPECT_GT(validRatio, 0.5);
 }
 
-void CV_GPU_SURFTest::compareKeypointSets(const vector<KeyPoint>& validKeypoints, const vector<KeyPoint>& calcKeypoints, 
-                                          const Mat& validDescriptors, const Mat& calcDescriptors)
+INSTANTIATE_TEST_CASE_P(Features2D, SURF, testing::ValuesIn(devices(cv::gpu::GLOBAL_ATOMICS)));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// BruteForceMatcher
+
+static const char* dists[] = {"L1Dist", "L2Dist", "HammingDist"};
+
+struct BruteForceMatcher : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, cv::gpu::BruteForceMatcher_GPU_base::DistType, int> >
 {
-    BruteForceMatcher< L2<float> > matcher;
-    vector<DMatch> matches;
+    static const int queryDescCount = 300; // must be even number because we split train data in some cases in two
+    static const int countFactor = 4; // do not change it
 
-    matcher.match(validDescriptors, calcDescriptors, matches);
-
-    int validCount = getValidCount(validKeypoints, calcKeypoints, matches);
-    float validRatio = (float)validCount / matches.size();
-
-    if (validRatio < 0.5f)
-    {
-        ts->printf(cvtest::TS::LOG, "Bad accuracy - %f.\n", validRatio);
-        ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
-        return;
-    }
-}
-
-void CV_GPU_SURFTest::accuracyTest()
-{
-    string imgFilename = string(ts->get_data_path()) + FEATURES2D_DIR + "/" + IMAGE_FILENAME;
-
-    // Read the test image.
-    Mat image = imread(imgFilename, 0);
-    if (image.empty())
-    {
-        ts->printf( cvtest::TS::LOG, "Image %s can not be read.\n", imgFilename.c_str() );
-        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
-        return;
-    }
+    cv::gpu::DeviceInfo devInfo;
+    cv::gpu::BruteForceMatcher_GPU_base::DistType distType;
+    int dim;
     
-    Mat mask(image.size(), CV_8UC1, Scalar::all(1));
-    mask(Range(0, image.rows / 2), Range(0, image.cols / 2)).setTo(Scalar::all(0));
+    cv::Mat query, train;
 
-    // Compute keypoints.
-    vector<KeyPoint> calcKeypoints;
-    GpuMat calcDescriptors;
-    SURF_GPU fdetector; fdetector.extended = false;
-    fdetector(GpuMat(image), GpuMat(mask), calcKeypoints, calcDescriptors);
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        distType = std::tr1::get<1>(GetParam());
+        dim = std::tr1::get<2>(GetParam());
 
-    // Calc validation keypoints set.
-    vector<KeyPoint> validKeypoints;
-    vector<float> validDescriptors;
-    SURF fdetector_gold; fdetector_gold.extended = false;
-    fdetector_gold(image, mask, validKeypoints, validDescriptors);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-    compareKeypointSets(validKeypoints, calcKeypoints, 
-        Mat(validKeypoints.size(), fdetector_gold.descriptorSize(), CV_32F, &validDescriptors[0]), calcDescriptors);
-}
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-void CV_GPU_SURFTest::run( int /*start_from*/ )
+        cv::Mat queryBuf, trainBuf;
+
+        // Generate query descriptors randomly.
+        // Descriptor vector elements are integer values.
+        queryBuf.create(queryDescCount, dim, CV_32SC1);
+        rng.fill(queryBuf, cv::RNG::UNIFORM, cv::Scalar::all(0), cv::Scalar::all(3));
+        queryBuf.convertTo(queryBuf, CV_32FC1);
+
+        // Generate train decriptors as follows:
+        // copy each query descriptor to train set countFactor times
+        // and perturb some one element of the copied descriptors in
+        // in ascending order. General boundaries of the perturbation
+        // are (0.f, 1.f).
+        trainBuf.create(queryDescCount * countFactor, dim, CV_32FC1);
+        float step = 1.f / countFactor;
+        for (int qIdx = 0; qIdx < queryDescCount; qIdx++)
+        {
+            cv::Mat queryDescriptor = queryBuf.row(qIdx);
+            for (int c = 0; c < countFactor; c++)
+            {
+                int tIdx = qIdx * countFactor + c;
+                cv::Mat trainDescriptor = trainBuf.row(tIdx);
+                queryDescriptor.copyTo(trainDescriptor);
+                int elem = rng(dim);
+                float diff = rng.uniform(step * c, step * (c + 1));
+                trainDescriptor.at<float>(0, elem) += diff;
+            }
+        }
+
+        queryBuf.convertTo(query, CV_32F);
+        trainBuf.convertTo(train, CV_32F);
+    }
+};
+
+const int BruteForceMatcher::queryDescCount;
+const int BruteForceMatcher::countFactor;
+
+TEST_P(BruteForceMatcher, Match)
 {
-    emptyDataTest();
-    accuracyTest();
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    std::vector<cv::DMatch> matches;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+
+        matcher.match(cv::gpu::GpuMat(query), cv::gpu::GpuMat(train), matches);
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        cv::DMatch match = matches[i];
+        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
+            badCount++;
+    }
+
+    ASSERT_EQ(0, badCount);
 }
 
-TEST(SURF, empty_data_and_accuracy) { CV_GPU_SURFTest test; test.safe_run(); }
+TEST_P(BruteForceMatcher, MatchAdd)
+{
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    std::vector<cv::DMatch> matches;
+
+    bool isMaskSupported;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows/2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows/2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++)
+        {
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount/2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+        }
+
+        matcher.match(cv::gpu::GpuMat(query), matches, masks);
+
+        isMaskSupported = matcher.isMaskSupported();
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        cv::DMatch match = matches[i];
+        int shift = isMaskSupported ? 1 : 0;
+        {
+            if (i < queryDescCount / 2)
+            {
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + shift) || (match.imgIdx != 0))
+                    badCount++;
+            }
+            else
+            {
+                if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + shift) || (match.imgIdx != 1))
+                    badCount++;
+            }
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, KnnMatch)
+{
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    const int knn = 3;
+
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+        matcher.knnMatch(cv::gpu::GpuMat(query), cv::gpu::GpuMat(train), matches, knn);
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                    localBadCount++;
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, KnnMatchAdd)
+{
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    const int knn = 2;
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    bool isMaskSupported;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++ )
+        {
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount / 2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+        }
+
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+
+        isMaskSupported = matcher.isMaskSupported();
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    int shift = isMaskSupported ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                {
+                    if (i < queryDescCount / 2)
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
+                    }
+                }
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, RadiusMatch)
+{
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+        return;
+
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    const float radius = 1.f / countFactor;
+
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+
+        matcher.radiusMatch(cv::gpu::GpuMat(query), cv::gpu::GpuMat(train), matches, radius);
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != 1)
+            badCount++;
+        else
+        {
+            cv::DMatch match = matches[i][0];
+            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
+                badCount++;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, RadiusMatchAdd)
+{
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+        return;
+
+    const char* distStr = dists[distType];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(distStr);
+    PRINT_PARAM(dim);
+
+    int n = 3;
+    const float radius = 1.f / countFactor * n;
+
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    bool isMaskSupported;
+
+    ASSERT_NO_THROW(
+        cv::gpu::BruteForceMatcher_GPU_base matcher(distType);
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++)
+        {
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount / 2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+        }
+
+        matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
+
+        isMaskSupported = matcher.isMaskSupported();
+    );
+
+    ASSERT_EQ(queryDescCount, matches.size());
+
+    int badCount = 0;
+    int shift = isMaskSupported ? 1 : 0;
+    int needMatchCount = isMaskSupported ? n-1 : n;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != needMatchCount)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < needMatchCount; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                {
+                    if (i < queryDescCount / 2)
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
+                    }
+                }
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+INSTANTIATE_TEST_CASE_P(Features2D, BruteForceMatcher, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(cv::gpu::BruteForceMatcher_GPU_base::L1Dist, cv::gpu::BruteForceMatcher_GPU_base::L2Dist),
+                        testing::Values(57, 64, 83, 128, 179, 256, 304)));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 91d1f14387..7392daff04 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -39,329 +39,529 @@
 //
 //M*/
 
-#include <iostream>
-#include <cmath>
-#include <limits>
 #include "test_precomp.hpp"
 
-using namespace cv;
-using namespace std;
-using namespace gpu;
+#ifdef HAVE_CUDA
 
-class CV_GpuNppFilterTest : public cvtest::BaseTest
+namespace
 {
-public:
-    CV_GpuNppFilterTest(const char* /*test_name*/, const char* /*test_funcs*/) {}
-    virtual ~CV_GpuNppFilterTest() {}
-
-protected:
-    void run(int);
-    virtual int test(const Mat& img) = 0;
-    
-    int test8UC1(const Mat& img)
+    double checkNorm(const cv::Mat& m1, const cv::Mat& m2, const cv::Size& ksize)
     {
-        cv::Mat img_C1;
-        cvtColor(img, img_C1, CV_BGR2GRAY);
-        return test(img_C1);
+        cv::Rect roi(ksize.width, ksize.height, m1.cols - 2 * ksize.width, m1.rows - 2 * ksize.height);
+        cv::Mat m1ROI = m1(roi);
+        cv::Mat m2ROI = m2(roi);
+        return ::checkNorm(m1ROI, m2ROI);
     }
 
-    int test8UC4(const Mat& img)
+    double checkNorm(const cv::Mat& m1, const cv::Mat& m2, int ksize)
     {
-        cv::Mat img_C4;
-        cvtColor(img, img_C4, CV_BGR2BGRA);
-        return test(img_C4);
+        return checkNorm(m1, m2, cv::Size(ksize, ksize));
     }
-        
-    int CheckNorm(const Mat& m1, const Mat& m2, const Size& ksize)
-    {
-        Rect roi = Rect(ksize.width, ksize.height, m1.cols - 2 * ksize.width, m1.rows - 2 * ksize.height);
-        Mat m1ROI = m1(roi);
-        Mat m2ROI = m2(roi);
-
-        double res = norm(m1ROI, m2ROI, NORM_INF);
-
-        // Max difference (2.0) in GaussianBlur
-        if (res <= 2)
-            return cvtest::TS::OK;
-        
-        ts->printf(cvtest::TS::LOG, "Norm: %f\n", res);
-        return cvtest::TS::FAIL_GENERIC;
-    }
-};
-
-void CV_GpuNppFilterTest::run( int )
-{    
-    cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
-    
-    if (img.empty())
-    {
-        ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-        return;
-    }
-
-    //run tests
-    int testResult = cvtest::TS::OK;
-
-    if (test8UC1(img) != cvtest::TS::OK)
-        testResult = cvtest::TS::FAIL_GENERIC;
-
-    if (test8UC4(img) != cvtest::TS::OK)
-        testResult = cvtest::TS::FAIL_GENERIC;
-
-    ts->set_failed_test_info(testResult);
-
-    ts->set_failed_test_info(cvtest::TS::OK);
 }
 
-////////////////////////////////////////////////////////////////////////////////
+#define EXPECT_MAT_NEAR_KSIZE(mat1, mat2, ksize, eps) \
+    { \
+        ASSERT_EQ(mat1.type(), mat2.type()); \
+        ASSERT_EQ(mat1.size(), mat2.size()); \
+        EXPECT_LE(checkNorm(mat1, mat2, ksize), eps); \
+    }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
 // blur
-struct CV_GpuNppImageBlurTest : public CV_GpuNppFilterTest
+
+struct Blur : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
 {
-    CV_GpuNppImageBlurTest() : CV_GpuNppFilterTest( "GPU-NppImageBlur", "blur" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size ksize;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
 
-    int test(const Mat& img)
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
     {
-        int ksizes[] = {3, 5, 7};
-        int ksizes_num = sizeof(ksizes) / sizeof(int);
+        devInfo = std::tr1::get<0>(GetParam());
+        ksize = cv::Size(std::tr1::get<1>(GetParam()), std::tr1::get<2>(GetParam()));
 
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < ksizes_num; ++i)
-        {
-            for (int j = 0; j < ksizes_num; ++j)
-            {
-                Size ksize(ksizes[i], ksizes[j]);
-
-                ts->printf(cvtest::TS::LOG, "\nksize = (%dx%d)\n", ksizes[i], ksizes[j]);
-
-                Mat cpudst;
-                cv::blur(img, cpudst, ksize);
-
-                GpuMat gpu1(img);
-                GpuMat gpudst;
-                cv::gpu::blur(gpu1, gpudst, ksize);
-
-                if (CheckNorm(cpudst, gpudst, ksize) != cvtest::TS::OK)
-                    test_res = cvtest::TS::FAIL_GENERIC;
-            }
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Sobel
-struct CV_GpuNppImageSobelTest : public CV_GpuNppFilterTest
-{
-    CV_GpuNppImageSobelTest() : CV_GpuNppFilterTest( "GPU-NppImageSobel", "Sobel" ) {}
-
-    int test(const Mat& img)
-    {
-        int ksizes[] = {3, 5, 7};
-        int ksizes_num = sizeof(ksizes) / sizeof(int);
-
-        int dx = 1, dy = 0;
-
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < ksizes_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nksize = %d\n", ksizes[i]);
-
-            Mat cpudst;
-            cv::Sobel(img, cpudst, -1, dx, dy, ksizes[i]);
-
-            GpuMat gpu1(img);
-            GpuMat gpudst;
-            cv::gpu::Sobel(gpu1, gpudst, -1, dx, dy, ksizes[i]);
-
-            if (CheckNorm(cpudst, gpudst, Size(ksizes[i], ksizes[i])) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Scharr
-struct CV_GpuNppImageScharrTest : public CV_GpuNppFilterTest
-{
-    CV_GpuNppImageScharrTest() : CV_GpuNppFilterTest( "GPU-NppImageScharr", "Scharr" ) {}
-
-    int test(const Mat& img)
-    {
-        int dx = 1, dy = 0;
-
-        Mat cpudst;
-        cv::Scharr(img, cpudst, -1, dx, dy);
-
-        GpuMat gpu1(img);
-        GpuMat gpudst;
-        cv::gpu::Scharr(gpu1, gpudst, -1, dx, dy);
+        cv::gpu::setDevice(devInfo.deviceID());
                 
-        return CheckNorm(cpudst, gpudst, Size(3, 3));
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+
+        cv::blur(img_rgba, dst_gold_rgba, ksize);
+        cv::blur(img_gray, dst_gold_gray, ksize);
     }
 };
 
-
-////////////////////////////////////////////////////////////////////////////////
-// GaussianBlur
-struct CV_GpuNppImageGaussianBlurTest : public CV_GpuNppFilterTest
+TEST_P(Blur, Accuracy)
 {
-    CV_GpuNppImageGaussianBlurTest() : CV_GpuNppFilterTest( "GPU-NppImageGaussianBlur", "GaussianBlur" ) {}
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(ksize);
 
-    int test(const Mat& img)
-    {
-        int ksizes[] = {3, 5, 7};
-        int ksizes_num = sizeof(ksizes) / sizeof(int);
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
 
-        int test_res = cvtest::TS::OK;
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
 
-        const double sigma1 = 3.0;
+        cv::gpu::blur(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, ksize);
+        cv::gpu::blur(cv::gpu::GpuMat(img_gray), dev_dst_gray, ksize);
 
-        for (int i = 0; i < ksizes_num; ++i)
-        {
-            for (int j = 0; j < ksizes_num; ++j)
-            {
-                cv::Size ksize(ksizes[i], ksizes[j]);
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
 
-                ts->printf(cvtest::TS::LOG, "ksize = (%dx%d)\t\n", ksizes[i], ksizes[j]);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 1.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 1.0);
+}
 
-                Mat cpudst;
-                cv::GaussianBlur(img, cpudst, ksize, sigma1);
+INSTANTIATE_TEST_CASE_P(Filter, Blur, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(3, 5, 7), 
+                        testing::Values(3, 5, 7)));
 
-                GpuMat gpu1(img);
-                GpuMat gpudst;
-                cv::gpu::GaussianBlur(gpu1, gpudst, ksize, sigma1);
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// sobel
 
-                if (CheckNorm(cpudst, gpudst, ksize) != cvtest::TS::OK)
-                    test_res = cvtest::TS::FAIL_GENERIC;
-            }
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Laplacian
-struct CV_GpuNppImageLaplacianTest : public CV_GpuNppFilterTest
+struct Sobel : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, std::pair<int, int> > >
 {
-    CV_GpuNppImageLaplacianTest() : CV_GpuNppFilterTest( "GPU-NppImageLaplacian", "Laplacian" ) {}
+    cv::gpu::DeviceInfo devInfo;
+    int ksize;
+    int dx, dy;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
 
-    int test(const Mat& img)
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
     {
-        int ksizes[] = {1, 3};
-        int ksizes_num = sizeof(ksizes) / sizeof(int);
+        devInfo = std::tr1::get<0>(GetParam());
+        ksize = std::tr1::get<1>(GetParam());
+        std::pair<int, int> d = std::tr1::get<2>(GetParam());
+        dx = d.first; dy = d.second;
 
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < ksizes_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nksize = %d\n", ksizes[i]);
-
-            Mat cpudst;
-            cv::Laplacian(img, cpudst, -1, ksizes[i]);
-
-            GpuMat gpu1(img);
-            GpuMat gpudst;
-            cv::gpu::Laplacian(gpu1, gpudst, -1, ksizes[i]);
-
-            if (CheckNorm(cpudst, gpudst, Size(3, 3)) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+        
+        cv::Sobel(img_rgba, dst_gold_rgba, -1, dx, dy, ksize);
+        cv::Sobel(img_gray, dst_gold_gray, -1, dx, dy, ksize);
     }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Erode
-class CV_GpuErodeTest : public CV_GpuNppFilterTest
+TEST_P(Sobel, Accuracy)
 {
-public:
-    CV_GpuErodeTest() : CV_GpuNppFilterTest( "GPU-NppErode", "erode" ) {} 
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(ksize);
+    PRINT_PARAM(dx);
+    PRINT_PARAM(dy);
 
-protected:
-	virtual int test(const Mat& img)
-    {
-        Mat kernel(Mat::ones(3, 3, CV_8U));
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
 
-	    cv::Mat cpuRes;
-        cv::erode(img, cpuRes, kernel);
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
 
-	    GpuMat gpuRes;
-        cv::gpu::erode(GpuMat(img), gpuRes, kernel);
+        cv::gpu::Sobel(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, -1, dx, dy, ksize);
+        cv::gpu::Sobel(cv::gpu::GpuMat(img_gray), dev_dst_gray, -1, dx, dy, ksize);
 
-	    return CheckNorm(cpuRes, gpuRes, Size(3, 3));
-    }
-};
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
 
-////////////////////////////////////////////////////////////////////////////////
-// Dilate
-class CV_GpuDilateTest : public CV_GpuNppFilterTest
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Sobel, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(3, 5, 7), 
+                        testing::Values(std::make_pair(1, 0), std::make_pair(0, 1), std::make_pair(1, 1), std::make_pair(2, 0), std::make_pair(2, 1), std::make_pair(0, 2), std::make_pair(1, 2), std::make_pair(2, 2))));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// scharr
+
+struct Scharr : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, std::pair<int, int> > >
 {
-public:
-    CV_GpuDilateTest() : CV_GpuNppFilterTest( "GPU-NppDilate", "dilate" ) {} 
+    cv::gpu::DeviceInfo devInfo;
+    int dx, dy;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
 
-protected:
-	virtual int test(const Mat& img)
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
     {
-        Mat kernel(Mat::ones(3, 3, CV_8U));
+        devInfo = std::tr1::get<0>(GetParam());
+        std::pair<int, int> d = std::tr1::get<1>(GetParam());
+        dx = d.first; dy = d.second;
 
-	    cv::Mat cpuRes;
-        cv::dilate(img, cpuRes, kernel);
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
 
-	    GpuMat gpuRes;
-        cv::gpu::dilate(GpuMat(img), gpuRes, kernel);
-	
-	    return CheckNorm(cpuRes, gpuRes, Size(3, 3));
+        cv::Scharr(img_rgba, dst_gold_rgba, -1, dx, dy);
+        cv::Scharr(img_gray, dst_gold_gray, -1, dx, dy);
     }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// MorphologyEx
-class CV_GpuMorphExTest : public CV_GpuNppFilterTest
+TEST_P(Scharr, Accuracy)
 {
-public:
-    CV_GpuMorphExTest() : CV_GpuNppFilterTest( "GPU-NppMorphologyEx", "morphologyEx" ) {} 
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(dx);
+    PRINT_PARAM(dy);
 
-protected:
-	virtual int test(const Mat& img)
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::Scharr(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, -1, dx, dy);
+        cv::gpu::Scharr(cv::gpu::GpuMat(img_gray), dev_dst_gray, -1, dx, dy);
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Scharr, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(std::make_pair(1, 0), std::make_pair(0, 1))));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// gaussianBlur
+
+struct GaussianBlur : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size ksize;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
+
+    double sigma1, sigma2;
+
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
     {
-        static int ops[] = { MORPH_OPEN, CV_MOP_CLOSE, CV_MOP_GRADIENT, CV_MOP_TOPHAT, CV_MOP_BLACKHAT};
-        const char *names[] = { "MORPH_OPEN", "CV_MOP_CLOSE", "CV_MOP_GRADIENT", "CV_MOP_TOPHAT", "CV_MOP_BLACKHAT"};
-        int num = sizeof(ops)/sizeof(ops[0]);
+        devInfo = std::tr1::get<0>(GetParam());
+        ksize = cv::Size(std::tr1::get<1>(GetParam()), std::tr1::get<2>(GetParam()));
 
-        GpuMat kernel(Mat::ones(3, 3, CV_8U));
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
 
-        int res = cvtest::TS::OK;
-
-        for(int i = 0; i < num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "Tesing %s\n", names[i]);
-
-	        cv::Mat cpuRes;
-            cv::morphologyEx(img, cpuRes, ops[i], (Mat)kernel);
-
-	        GpuMat gpuRes;
-            cv::gpu::morphologyEx(GpuMat(img), gpuRes, ops[i], kernel);
-
-            if (cvtest::TS::OK != CheckNorm(cpuRes, gpuRes, Size(4, 4)))
-                res = cvtest::TS::FAIL_GENERIC;
-        }
-        return res;
+        sigma1 = rng.uniform(0.1, 1.0); 
+        sigma2 = rng.uniform(0.1, 1.0);
+        
+        cv::GaussianBlur(img_rgba, dst_gold_rgba, ksize, sigma1, sigma2);
+        cv::GaussianBlur(img_gray, dst_gold_gray, ksize, sigma1, sigma2);
     }
 };
 
+TEST_P(GaussianBlur, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(ksize);
+    PRINT_PARAM(sigma1);
+    PRINT_PARAM(sigma2);
 
-TEST(blur, accuracy) { CV_GpuNppImageBlurTest test; test.safe_run(); }
-TEST(sobel, accuracy) { CV_GpuNppImageSobelTest test; test.safe_run(); }
-TEST(scharr, accuracy) { CV_GpuNppImageScharrTest test; test.safe_run(); }
-TEST(gaussianBlur, accuracy) { CV_GpuNppImageGaussianBlurTest test; test.safe_run(); }
-TEST(laplcaian, accuracy) { CV_GpuNppImageLaplacianTest test; test.safe_run(); }
-TEST(erode, accuracy) { CV_GpuErodeTest test; test.safe_run(); }
-TEST(dilate, accuracy) { CV_GpuDilateTest test; test.safe_run(); }
-TEST(morphEx, accuracy) { CV_GpuMorphExTest test;  test.safe_run(); }
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::GaussianBlur(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, ksize, sigma1, sigma2);
+        cv::gpu::GaussianBlur(cv::gpu::GpuMat(img_gray), dev_dst_gray, ksize, sigma1, sigma2);
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, ksize, 3.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, ksize, 3.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, GaussianBlur, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(3, 5, 7), 
+                        testing::Values(3, 5, 7)));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// laplacian
+
+struct Laplacian : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int ksize;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
+
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        ksize = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+
+        cv::Laplacian(img_rgba, dst_gold_rgba, -1, ksize);
+        cv::Laplacian(img_gray, dst_gold_gray, -1, ksize);
+    }
+};
+
+TEST_P(Laplacian, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(ksize);
+
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::Laplacian(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, -1, ksize);
+        cv::gpu::Laplacian(cv::gpu::GpuMat(img_gray), dev_dst_gray, -1, ksize);
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Laplacian, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(1, 3)));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// erode
+
+struct Erode : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
+
+    cv::Mat kernel;
+
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        kernel = cv::Mat::ones(3, 3, CV_8U);
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+
+        cv::erode(img_rgba, dst_gold_rgba, kernel);
+        cv::erode(img_gray, dst_gold_gray, kernel);
+    }
+};
+
+TEST_P(Erode, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::erode(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, kernel);
+        cv::gpu::erode(cv::gpu::GpuMat(img_gray), dev_dst_gray, kernel);
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Erode, testing::ValuesIn(devices()));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// dilate
+
+struct Dilate : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
+
+    cv::Mat kernel;
+
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        kernel = cv::Mat::ones(3, 3, CV_8U);
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+
+        cv::dilate(img_rgba, dst_gold_rgba, kernel);
+        cv::dilate(img_gray, dst_gold_gray, kernel);
+    }
+};
+
+TEST_P(Dilate, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::dilate(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, kernel);
+        cv::gpu::dilate(cv::gpu::GpuMat(img_gray), dev_dst_gray, kernel);
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 3, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 3, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, Dilate, testing::ValuesIn(devices()));
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+// morphEx
+
+static const int morphOps[] = {cv::MORPH_OPEN, CV_MOP_CLOSE, CV_MOP_GRADIENT, CV_MOP_TOPHAT, CV_MOP_BLACKHAT};
+static const char* morphOps_str[] = {"MORPH_OPEN", "MOP_CLOSE", "MOP_GRADIENT", "MOP_TOPHAT", "MOP_BLACKHAT"};
+
+struct MorphEx : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int morphOpsIdx;
+    
+    cv::Mat img_rgba;
+    cv::Mat img_gray;
+
+    cv::Mat kernel;
+
+    cv::Mat dst_gold_rgba;
+    cv::Mat dst_gold_gray;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        morphOpsIdx = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobp/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, img_rgba, CV_BGR2BGRA);
+        cv::cvtColor(img, img_gray, CV_BGR2GRAY);
+
+        kernel = cv::Mat::ones(3, 3, CV_8U);
+        
+        cv::morphologyEx(img_rgba, dst_gold_rgba, morphOps[morphOpsIdx], kernel);
+        cv::morphologyEx(img_gray, dst_gold_gray, morphOps[morphOpsIdx], kernel);
+    }
+};
+
+TEST_P(MorphEx, Accuracy)
+{
+    const char* morphOpStr = morphOps_str[morphOpsIdx];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(morphOpStr);
+
+    cv::Mat dst_rgba;
+    cv::Mat dst_gray;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst_rgba;
+        cv::gpu::GpuMat dev_dst_gray;
+
+        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_rgba), dev_dst_rgba, morphOps[morphOpsIdx], cv::gpu::GpuMat(kernel));
+        cv::gpu::morphologyEx(cv::gpu::GpuMat(img_gray), dev_dst_gray, morphOps[morphOpsIdx], cv::gpu::GpuMat(kernel));
+
+        dev_dst_rgba.download(dst_rgba);
+        dev_dst_gray.download(dst_gray);
+    );
+
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_rgba, dst_rgba, 4, 0.0);
+    EXPECT_MAT_NEAR_KSIZE(dst_gold_gray, dst_gray, 4, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(Filter, MorphEx, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Range(0, 5)));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_gpu_base.cpp b/modules/gpu/test/test_gpu_base.cpp
new file mode 100644
index 0000000000..f035d7a3ca
--- /dev/null
+++ b/modules/gpu/test/test_gpu_base.cpp
@@ -0,0 +1,154 @@
+/*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*/
+
+#include "test_precomp.hpp"
+
+bool supportFeature(const cv::gpu::DeviceInfo& info, cv::gpu::FeatureSet feature)
+{
+    return cv::gpu::TargetArchs::builtWith(feature) && info.supports(feature);
+}
+
+const std::vector<cv::gpu::DeviceInfo>& devices()
+{
+    static std::vector<cv::gpu::DeviceInfo> devs;
+    static bool first = true;
+
+    if (first)
+    {
+        int deviceCount = cv::gpu::getCudaEnabledDeviceCount();
+
+        devs.reserve(deviceCount);
+
+        for (int i = 0; i < deviceCount; ++i)
+        {
+            cv::gpu::DeviceInfo info(i);
+            if (info.isCompatible())
+                devs.push_back(info);
+        }
+
+        first = false;
+    }
+
+    return devs;
+}
+
+std::vector<cv::gpu::DeviceInfo> devices(cv::gpu::FeatureSet feature)
+{
+    const std::vector<cv::gpu::DeviceInfo>& d = devices();
+    
+    std::vector<cv::gpu::DeviceInfo> devs_filtered;
+
+    if (cv::gpu::TargetArchs::builtWith(feature))
+    {
+        devs_filtered.reserve(d.size());
+
+        for (size_t i = 0, size = d.size(); i < size; ++i)
+        {
+            const cv::gpu::DeviceInfo& info = d[i];
+
+            if (info.supports(feature))
+                devs_filtered.push_back(info);
+        }
+    }
+
+    return devs_filtered;
+}
+
+std::vector<int> types(int depth_start, int depth_end, int cn_start, int cn_end)
+{
+    std::vector<int> v;
+
+    v.reserve((depth_end - depth_start + 1) * (cn_end - cn_start + 1));
+
+    for (int depth = depth_start; depth <= depth_end; ++depth)
+    {
+        for (int cn = cn_start; cn <= cn_end; ++cn)
+        {
+            v.push_back(CV_MAKETYPE(depth, cn));
+        }
+    }
+
+    return v;
+}
+
+const std::vector<int>& all_types()
+{
+    static std::vector<int> v = types(CV_8U, CV_64F, 1, 4);
+    return v;
+}
+
+cv::Mat readImage(const std::string& fileName, int flags)
+{
+    return cv::imread(std::string(cvtest::TS::ptr()->get_data_path()) + fileName, flags);
+}
+
+double checkNorm(const cv::Mat& m1, const cv::Mat& m2)
+{
+    return cv::norm(m1, m2, cv::NORM_INF);
+}
+
+double checkSimilarity(const cv::Mat& m1, const cv::Mat& m2)
+{
+    cv::Mat diff;
+    cv::matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
+    return std::abs(diff.at<float>(0, 0) - 1.f);
+}
+
+namespace cv
+{
+    std::ostream& operator << (std::ostream& os, const Size& sz)
+    {
+        return os << sz.width << "x" << sz.height;
+    }
+
+    std::ostream& operator << (std::ostream& os, const Scalar& s)
+    {
+        return os << "[" << s[0] << ", " << s[1] << ", " << s[2] << ", " << s[3] << "]";
+    }
+
+    namespace gpu
+    {
+        std::ostream& operator << (std::ostream& os, const DeviceInfo& info)
+        {
+            return os << info.name();
+        }
+    }
+}
diff --git a/modules/gpu/test/test_gpu_base.hpp b/modules/gpu/test/test_gpu_base.hpp
new file mode 100644
index 0000000000..25bf163a3d
--- /dev/null
+++ b/modules/gpu/test/test_gpu_base.hpp
@@ -0,0 +1,103 @@
+/*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_TEST_GPU_BASE_HPP__
+#define __OPENCV_TEST_GPU_BASE_HPP__
+
+//! return true if device supports specified feature and gpu module was built with support the feature.
+bool supportFeature(const cv::gpu::DeviceInfo& info, cv::gpu::FeatureSet feature);
+
+//! return all devices compatible with current gpu module build.
+const std::vector<cv::gpu::DeviceInfo>& devices();
+//! return all devices compatible with current gpu module build which support specified feature.
+std::vector<cv::gpu::DeviceInfo> devices(cv::gpu::FeatureSet feature);
+
+//! return vector with types from specified range.
+std::vector<int> types(int depth_start, int depth_end, int cn_start, int cn_end);
+
+//! return vector with all types (depth: CV_8U-CV_64F, channels: 1-4).
+const std::vector<int>& all_types();
+
+//! read image from testdata folder.
+cv::Mat readImage(const std::string& fileName, int flags = CV_LOAD_IMAGE_COLOR);
+
+double checkNorm(const cv::Mat& m1, const cv::Mat& m2);
+double checkSimilarity(const cv::Mat& m1, const cv::Mat& m2);
+
+#define OSTR_NAME(suf) ostr_ ## suf
+
+#define PRINT_PARAM(name) \
+        std::ostringstream OSTR_NAME(name); \
+        OSTR_NAME(name) << # name << ": " << name; \
+        SCOPED_TRACE(OSTR_NAME(name).str());
+
+#define PRINT_TYPE(type) \
+        std::ostringstream OSTR_NAME(type); \
+        OSTR_NAME(type) << # type << ": " << cvtest::getTypeName(type) << "c" << CV_MAT_CN(type); \
+        SCOPED_TRACE(OSTR_NAME(type).str());
+
+#define EXPECT_MAT_NEAR(mat1, mat2, eps) \
+    { \
+        ASSERT_EQ(mat1.type(), mat2.type()); \
+        ASSERT_EQ(mat1.size(), mat2.size()); \
+        EXPECT_LE(checkNorm(mat1, mat2), eps); \
+    }
+
+#define EXPECT_MAT_SIMILAR(mat1, mat2, eps) \
+    { \
+        ASSERT_EQ(mat1.type(), mat2.type()); \
+        ASSERT_EQ(mat1.size(), mat2.size()); \
+        EXPECT_LE(checkSimilarity(mat1, mat2), eps); \
+    }
+
+
+//! for gtest ASSERT
+namespace cv
+{
+    std::ostream& operator << (std::ostream& os, const Size& sz);
+    std::ostream& operator << (std::ostream& os, const Scalar& s);
+    namespace gpu
+    {
+        std::ostream& operator << (std::ostream& os, const DeviceInfo& info);
+    }
+}
+
+#endif // __OPENCV_TEST_GPU_BASE_HPP__
diff --git a/modules/gpu/test/test_hog.cpp b/modules/gpu/test/test_hog.cpp
index c6089b0766..548e3e51c8 100644
--- a/modules/gpu/test/test_hog.cpp
+++ b/modules/gpu/test/test_hog.cpp
@@ -40,32 +40,24 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include <fstream>
 
-using namespace std;
+#ifdef HAVE_CUDA
 
 //#define DUMP
 
-#define CHECK(pred, err) if (!(pred)) { \
-    ts->printf(cvtest::TS::CONSOLE, "Fail: \"%s\" at line: %d\n", #pred, __LINE__); \
-    ts->set_failed_test_info(err); \
-    return; }
-
-struct CV_GpuHogDetectTestRunner: cv::gpu::HOGDescriptor
+struct CV_GpuHogDetectTestRunner : cv::gpu::HOGDescriptor
 {
-    CV_GpuHogDetectTestRunner(cvtest::TS* ts_): ts(ts_) {}
-
-    void run(int) 
+    void run() 
     {       
-        cv::Mat img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/road.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        cv::Mat img_rgb = readImage("hog/road.png");
+        ASSERT_FALSE(img_rgb.empty());
 
 #ifdef DUMP
-        f.open((std::string(ts->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        CHECK(f.is_open(), cvtest::TS::FAIL_GENERIC);
+        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+        ASSERT_TRUE(f.is_open());
 #else
-        f.open((std::string(ts->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        CHECK(f.is_open(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+        ASSERT_TRUE(f.is_open());
 #endif
 
         // Test on color image
@@ -78,7 +70,6 @@ struct CV_GpuHogDetectTestRunner: cv::gpu::HOGDescriptor
         test(img);
 
         f.close();
-
     }
 
 #ifdef DUMP
@@ -107,24 +98,24 @@ struct CV_GpuHogDetectTestRunner: cv::gpu::HOGDescriptor
 
         f.read((char*)&rows, sizeof(rows));
         f.read((char*)&cols, sizeof(cols));
-        CHECK(rows == block_hists.rows, cvtest::TS::FAIL_INVALID_OUTPUT);
-        CHECK(cols == block_hists.cols, cvtest::TS::FAIL_INVALID_OUTPUT);
+        ASSERT_EQ(rows, block_hists.rows);
+        ASSERT_EQ(cols, block_hists.cols);
         for (int i = 0; i < block_hists.rows; ++i)
         {
             for (int j = 0; j < block_hists.cols; ++j)
             {
                 float val;
                 f.read((char*)&val, sizeof(val));
-                CHECK(fabs(val - block_hists.at<float>(i, j)) < 1e-3f, cvtest::TS::FAIL_INVALID_OUTPUT);
+                ASSERT_NEAR(val, block_hists.at<float>(i, j), 1e-3);
             }
         }
         f.read((char*)&nlocations, sizeof(nlocations));
-        CHECK(nlocations == static_cast<int>(locations.size()), cvtest::TS::FAIL_INVALID_OUTPUT);
+        ASSERT_EQ(nlocations, static_cast<int>(locations.size()));
         for (int i = 0; i < nlocations; ++i)
         {
             cv::Point location;
             f.read((char*)&location, sizeof(location));
-            CHECK(location == locations[i], cvtest::TS::FAIL_INVALID_OUTPUT);
+            ASSERT_EQ(location, locations[i]);
         }
     }
 #endif
@@ -176,39 +167,47 @@ struct CV_GpuHogDetectTestRunner: cv::gpu::HOGDescriptor
 #else
     std::ifstream f;
 #endif
-
-    cvtest::TS* ts;
 };
 
-
-struct CV_GpuHogDetectTest: cvtest::BaseTest 
+struct HogDetect : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuHogDetectTest() {}
-
-    void run(int i)
+    cv::gpu::DeviceInfo devInfo;
+    
+    virtual void SetUp()
     {
-        CV_GpuHogDetectTestRunner runner(ts);
-        runner.run(i);
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
     }
 };
 
-TEST(HOG, detect_accuracy) { CV_GpuHogDetectTest test; test.safe_run(); }
-
-struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
+TEST_P(HogDetect, Accuracy)
 {
-    CV_GpuHogGetDescriptorsTestRunner(cvtest::TS* ts_): HOGDescriptor(cv::Size(64, 128)), ts(ts_) {}
+    PRINT_PARAM(devInfo);
 
-    void run(int)
+    ASSERT_NO_THROW(
+        CV_GpuHogDetectTestRunner runner;
+        runner.run();
+    );
+}
+
+INSTANTIATE_TEST_CASE_P(HOG, HogDetect, testing::ValuesIn(devices()));
+
+struct CV_GpuHogGetDescriptorsTestRunner : cv::gpu::HOGDescriptor
+{
+    CV_GpuHogGetDescriptorsTestRunner(): cv::gpu::HOGDescriptor(cv::Size(64, 128)) {}
+
+    void run()
     {
         // Load image (e.g. train data, composed from windows)
-        cv::Mat img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/train_data.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        cv::Mat img_rgb = readImage("hog/train_data.png");
+        ASSERT_FALSE(img_rgb.empty());
 
         // Convert to C4
         cv::Mat img;
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        cv::gpu::GpuMat d_img(img);
 
+        cv::gpu::GpuMat d_img(img);
 
         // Convert train images into feature vectors (train table)
         cv::gpu::GpuMat descriptors, descriptors_by_cols;
@@ -223,7 +222,7 @@ struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
         block_hist_size = 36;
         cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
                                                 wins_per_img_x * wins_per_img_y);
-        CHECK(descriptors.size() == descr_size_expected, cvtest::TS::FAIL_INVALID_OUTPUT);
+        ASSERT_EQ(descr_size_expected, descriptors.size());
 
         // Check both formats of output descriptors are handled correctly
         cv::Mat dr(descriptors);
@@ -235,8 +234,8 @@ struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
             for (int y = 0; y < blocks_per_win_y; ++y)
                 for (int x = 0; x < blocks_per_win_x; ++x)
                     for (int k = 0; k < block_hist_size; ++k)
-                        CHECK(l[(y * blocks_per_win_x + x) * block_hist_size + k] ==
-                              r[(x * blocks_per_win_y + y) * block_hist_size + k], cvtest::TS::FAIL_INVALID_OUTPUT);
+                        ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
+                                  r[(x * blocks_per_win_y + y) * block_hist_size + k]);
         }
 
         /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
@@ -244,39 +243,39 @@ struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
         wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
         works good, it can be checked in the gpu_hog sample */
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/positive1.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/positive1.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         // Everything is fine with interpolation for left top subimage
-        CHECK(cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)) == 0.f, cvtest::TS::FAIL_INVALID_OUTPUT);
+        ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/positive2.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/positive2.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         compare_inner_parts(block_hists, descriptors.rowRange(1, 2));
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/negative1.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/negative1.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         compare_inner_parts(block_hists, descriptors.rowRange(2, 3));
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/negative2.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/negative2.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         compare_inner_parts(block_hists, descriptors.rowRange(3, 4));
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/positive3.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/positive3.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         compare_inner_parts(block_hists, descriptors.rowRange(4, 5));
 
-        img_rgb = cv::imread(std::string(ts->get_data_path()) + "hog/negative3.png");
-        CHECK(!img_rgb.empty(), cvtest::TS::FAIL_MISSING_TEST_DATA);
+        img_rgb = readImage("hog/negative3.png");
+        ASSERT_TRUE(!img_rgb.empty());
         cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
         computeBlockHistograms(cv::gpu::GpuMat(img));
         compare_inner_parts(block_hists, descriptors.rowRange(5, 6));
@@ -291,7 +290,7 @@ struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
                 {
                     float a = d1.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
                     float b = d2.at<float>(0, (i * blocks_per_win_x + j) * block_hist_size);
-                    CHECK(a == b, cvtest::TS::FAIL_INVALID_OUTPUT)
+                    ASSERT_FLOAT_EQ(a, b);
                 }
     }
 
@@ -300,20 +299,30 @@ struct CV_GpuHogGetDescriptorsTestRunner: cv::gpu::HOGDescriptor
     int blocks_per_win_x;
     int blocks_per_win_y;
     int block_hist_size;
-
-    cvtest::TS* ts;
 };
 
-
-struct CV_GpuHogGetDescriptorsTest: cvtest::BaseTest 
+struct HogGetDescriptors : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    CV_GpuHogGetDescriptorsTest() {}
-
-    void run(int i)
+    cv::gpu::DeviceInfo devInfo;
+    
+    virtual void SetUp()
     {
-        CV_GpuHogGetDescriptorsTestRunner runner(ts);
-        runner.run(i);
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
     }
 };
 
-TEST(HOG, descriptors_accuracy) { CV_GpuHogGetDescriptorsTest test; test.safe_run(); }
+TEST_P(HogGetDescriptors, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    ASSERT_NO_THROW(
+        CV_GpuHogGetDescriptorsTestRunner runner;
+        runner.run();
+    );
+}
+
+INSTANTIATE_TEST_CASE_P(HOG, HogGetDescriptors, testing::ValuesIn(devices()));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
new file mode 100644
index 0000000000..cc39a1323c
--- /dev/null
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -0,0 +1,2250 @@
+/*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*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// threshold
+
+struct Threshold : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int threshOp;
+
+    cv::Size size;
+    cv::Mat src;
+    double maxVal;
+    double thresh;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        threshOp = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+
+        maxVal = rng.uniform(20.0, 127.0);
+        thresh = rng.uniform(0.0, maxVal);
+
+        cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+    }
+};
+
+TEST_P(Threshold, Accuracy)
+{
+    static const char* ops[] = {"THRESH_BINARY", "THRESH_BINARY_INV", "THRESH_TRUNC", "THRESH_TOZERO", "THRESH_TOZERO_INV"};
+    const char* threshOpStr = ops[threshOp];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(threshOpStr);
+    PRINT_PARAM(maxVal);
+    PRINT_PARAM(thresh);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::threshold(cv::gpu::GpuMat(src), gpuRes, thresh, maxVal, threshOp);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Threshold, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8U, CV_32F), 
+                        testing::Values((int)cv::THRESH_BINARY, (int)cv::THRESH_BINARY_INV, (int)cv::THRESH_TRUNC, (int)cv::THRESH_TOZERO, (int)cv::THRESH_TOZERO_INV)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// resize
+
+struct Resize : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int interpolation;
+
+    cv::Size size;
+    cv::Mat src;
+
+    cv::Mat dst_gold1;
+    cv::Mat dst_gold2;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        interpolation = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+
+        cv::resize(src, dst_gold1, cv::Size(), 2.0, 2.0, interpolation);
+        cv::resize(src, dst_gold2, cv::Size(), 0.5, 0.5, interpolation);
+    }
+};
+
+TEST_P(Resize, Accuracy)
+{
+    static const char* interpolations[] = {"INTER_NEAREST", "INTER_LINEAR"};
+    const char* interpolationStr = interpolations[interpolation];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(interpolationStr);
+
+    cv::Mat dst1;
+    cv::Mat dst2;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_src(src);
+        cv::gpu::GpuMat gpuRes1;
+        cv::gpu::GpuMat gpuRes2;
+
+        cv::gpu::resize(dev_src, gpuRes1, cv::Size(), 2.0, 2.0, interpolation);
+        cv::gpu::resize(dev_src, gpuRes2, cv::Size(), 0.5, 0.5, interpolation);
+
+        gpuRes1.download(dst1);
+        gpuRes2.download(dst2);
+    );
+
+    EXPECT_MAT_SIMILAR(dst_gold1, dst1, 0.5);
+    EXPECT_MAT_SIMILAR(dst_gold2, dst2, 0.5);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Resize, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_8UC4), 
+                        testing::Values((int)cv::INTER_NEAREST, (int)cv::INTER_LINEAR)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// remap
+
+struct Remap : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat src;
+    cv::Mat xmap;
+    cv::Mat ymap;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+        xmap = cvtest::randomMat(rng, size, CV_32FC1, 0.0, src.cols - 1, false);
+        ymap = cvtest::randomMat(rng, size, CV_32FC1, 0.0, src.rows - 1, false);
+        
+        cv::remap(src, dst_gold, xmap, ymap, cv::INTER_LINEAR, cv::BORDER_WRAP);
+    }
+};
+
+TEST_P(Remap, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+        
+        cv::gpu::remap(cv::gpu::GpuMat(src), gpuRes, cv::gpu::GpuMat(xmap), cv::gpu::GpuMat(ymap));
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 0.5);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Remap, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_8UC3)));
+                        
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// copyMakeBorder
+
+struct CopyMakeBorder : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat src;
+    int top;
+    int botton;
+    int left;
+    int right;
+    cv::Scalar val;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+        
+        top = rng.uniform(1, 10);
+        botton = rng.uniform(1, 10);
+        left = rng.uniform(1, 10);
+        right = rng.uniform(1, 10);
+        val = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
+
+        cv::copyMakeBorder(src, dst_gold, top, botton, left, right, cv::BORDER_CONSTANT, val);
+    }
+};
+
+TEST_P(CopyMakeBorder, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(top);
+    PRINT_PARAM(botton);
+    PRINT_PARAM(left);
+    PRINT_PARAM(right);
+    PRINT_PARAM(val);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::copyMakeBorder(cv::gpu::GpuMat(src), gpuRes, top, botton, left, right, val);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, CopyMakeBorder, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_8UC4, CV_32SC1)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// warpAffine & warpPerspective
+
+static const int warpFlags[] = {cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::INTER_NEAREST | cv::WARP_INVERSE_MAP, cv::INTER_LINEAR | cv::WARP_INVERSE_MAP, cv::INTER_CUBIC | cv::WARP_INVERSE_MAP};
+static const char* warpFlags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"};
+
+struct WarpAffine : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int flagIdx;
+
+    cv::Size size;
+    cv::Mat src;
+    cv::Mat M;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        flagIdx = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+
+        static double reflect[2][3] = { {-1,  0, 0},
+                                        { 0, -1, 0}};
+        reflect[0][2] = size.width;
+        reflect[1][2] = size.height;
+        M = cv::Mat(2, 3, CV_64F, (void*)reflect); 
+
+        cv::warpAffine(src, dst_gold, M, src.size(), warpFlags[flagIdx]);       
+    }
+};
+
+TEST_P(WarpAffine, Accuracy)
+{
+    const char* warpFlagStr = warpFlags_str[flagIdx];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(warpFlagStr);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::warpAffine(cv::gpu::GpuMat(src), gpuRes, M, src.size(), warpFlags[flagIdx]);
+
+        gpuRes.download(dst);
+    );
+
+    // Check inner parts (ignoring 1 pixel width border)
+    cv::Mat dst_gold_roi = dst_gold.rowRange(1, dst_gold.rows - 1).colRange(1, dst_gold.cols - 1);
+    cv::Mat dst_roi = dst.rowRange(1, dst.rows - 1).colRange(1, dst.cols - 1);
+
+    EXPECT_MAT_NEAR(dst_gold_roi, dst_roi, 1e-3);
+}
+
+struct WarpPerspective : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int flagIdx;
+
+    cv::Size size;
+    cv::Mat src;
+    cv::Mat M;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        flagIdx = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+
+        static double reflect[3][3] = { { -1, 0, 0},
+                                        { 0, -1, 0},
+                                        { 0,  0, 1}};
+        reflect[0][2] = size.width;
+        reflect[1][2] = size.height;
+        M = cv::Mat(3, 3, CV_64F, (void*)reflect);
+
+        cv::warpPerspective(src, dst_gold, M, src.size(), warpFlags[flagIdx]);       
+    }
+};
+
+TEST_P(WarpPerspective, Accuracy)
+{
+    const char* warpFlagStr = warpFlags_str[flagIdx];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(warpFlagStr);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::warpPerspective(cv::gpu::GpuMat(src), gpuRes, M, src.size(), warpFlags[flagIdx]);
+
+        gpuRes.download(dst);
+    );
+
+    // Check inner parts (ignoring 1 pixel width border)
+    cv::Mat dst_gold_roi = dst_gold.rowRange(1, dst_gold.rows - 1).colRange(1, dst_gold.cols - 1);
+    cv::Mat dst_roi = dst.rowRange(1, dst.rows - 1).colRange(1, dst.cols - 1);
+
+    EXPECT_MAT_NEAR(dst_gold_roi, dst_roi, 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpAffine, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
+                        testing::Range(0, 6)));
+
+INSTANTIATE_TEST_CASE_P(ImgProc, WarpPerspective, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4),
+                        testing::Range(0, 6)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// integral
+
+struct Integral : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Size size;
+    cv::Mat src;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, CV_8UC1, 0.0, 255.0, false); 
+
+        cv::integral(src, dst_gold, CV_32S);     
+    }
+};
+
+TEST_P(Integral, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::integral(cv::gpu::GpuMat(src), gpuRes);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Integral, testing::ValuesIn(devices()));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// cvtColor
+
+struct CvtColor : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    
+    cv::Mat img;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat imgBase = readImage("stereobm/aloe-L.png");
+        ASSERT_FALSE(imgBase.empty());
+
+        imgBase.convertTo(img, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
+    }
+};
+
+TEST_P(CvtColor, BGR2RGB)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2RGB);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2RGB);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2RGBA)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2RGBA);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2RGBA);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGRA2RGB)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2BGRA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGRA2RGB);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGRA2RGB);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CvtColor, BGR2YCrCb)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2YCrCb);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2YCrCb);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YCrCb2RGB)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_YCrCb2RGB);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_YCrCb2RGB);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2YUV)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2YUV);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2YUV);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, YUV2BGR)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_YUV2BGR);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_YUV2BGR);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2XYZ)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2XYZ);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2XYZ);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, XYZ2BGR)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_XYZ2BGR);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_XYZ2BGR);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2HSV)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2HSV);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2HSV);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2BGR)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_HSV2BGR);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_HSV2BGR);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HSV_FULL)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2HSV_FULL);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2HSV_FULL);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HSV2BGR_FULL)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_HSV2BGR_FULL);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_HSV2BGR_FULL);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HLS)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2HLS);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2HLS);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2BGR)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_HLS2BGR);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_HLS2BGR);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2HLS_FULL)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2HLS_FULL);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2HLS_FULL);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, HLS2BGR_FULL)
+{
+    if (type == CV_16U)
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_HLS2BGR_FULL);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_HLS2BGR_FULL);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, type == CV_32F ? 1e-2 : 1);
+}
+
+TEST_P(CvtColor, BGR2GRAY)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src = img;
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_BGR2GRAY);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_BGR2GRAY);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+}
+
+TEST_P(CvtColor, GRAY2RGB)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+
+    cv::Mat src;
+    cv::cvtColor(img, src, CV_BGR2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, CV_GRAY2RGB);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuRes;
+
+        cv::gpu::cvtColor(cv::gpu::GpuMat(src), gpuRes, CV_GRAY2RGB);
+
+        gpuRes.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, CvtColor, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8U, CV_16U, CV_32F)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// histograms
+
+struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat hsv;
+    
+    int hbins;
+    float hranges[2];
+
+    cv::Mat hist_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobm/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, hsv, CV_BGR2HSV);
+
+        hbins = 30;
+
+        hranges[0] = 0;
+        hranges[1] = 180;
+
+        int histSize[] = {hbins};
+        const float* ranges[] = {hranges};
+
+        cv::MatND histnd;
+
+        int channels[] = {0};
+        cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
+
+        hist_gold = histnd;
+        hist_gold = hist_gold.t();
+        hist_gold.convertTo(hist_gold, CV_32S);
+    }
+};
+
+TEST_P(HistEven, Accuracy)
+{
+    ASSERT_TRUE(!hsv.empty());
+
+    PRINT_PARAM(devInfo);
+
+    cv::Mat hist;
+    
+    ASSERT_NO_THROW(
+        std::vector<cv::gpu::GpuMat> srcs;
+        cv::gpu::split(cv::gpu::GpuMat(hsv), srcs);
+
+        cv::gpu::GpuMat gpuHist;
+
+        cv::gpu::histEven(srcs[0], gpuHist, hbins, (int)hranges[0], (int)hranges[1]);
+
+        gpuHist.download(hist);
+    );
+
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, HistEven, testing::ValuesIn(devices()));
+
+struct CalcHist : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Size size;
+    cv::Mat src;
+    cv::Mat hist_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        src = cvtest::randomMat(rng, size, CV_8UC1, 0, 255, false);
+
+        hist_gold.create(1, 256, CV_32SC1);
+        hist_gold.setTo(cv::Scalar::all(0));
+
+        int* hist = hist_gold.ptr<int>();
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const uchar* src_row = src.ptr(y);
+
+            for (int x = 0; x < src.cols; ++x)
+                ++hist[src_row[x]];
+        }
+    }
+};
+
+TEST_P(CalcHist, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat hist;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuHist;
+
+        cv::gpu::calcHist(cv::gpu::GpuMat(src), gpuHist);
+
+        gpuHist.download(hist);
+    );
+
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, CalcHist, testing::ValuesIn(devices()));
+
+struct EqualizeHist : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Size size;
+    cv::Mat src;
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 200), rng.uniform(100, 200));
+        
+        src = cvtest::randomMat(rng, size, CV_8UC1, 0, 255, false);
+
+        cv::equalizeHist(src, dst_gold);
+    }
+};
+
+TEST_P(EqualizeHist, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpuDst;
+
+        cv::gpu::equalizeHist(cv::gpu::GpuMat(src), gpuDst);
+
+        gpuDst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, EqualizeHist, testing::ValuesIn(devices()));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// cornerHarris
+
+static const int borderTypes[] = {cv::BORDER_REPLICATE, cv::BORDER_CONSTANT, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT101, cv::BORDER_TRANSPARENT};
+static const char* borderTypes_str[] = {"BORDER_REPLICATE", "BORDER_CONSTANT", "BORDER_REFLECT", "BORDER_WRAP", "BORDER_REFLECT101", "BORDER_TRANSPARENT"};
+
+struct CornerHarris : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int borderTypeIdx;
+
+    cv::Mat src;
+    int blockSize;
+    int apertureSize;        
+    double k;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        borderTypeIdx = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+        
+        cv::Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);
+        ASSERT_FALSE(img.empty());
+        
+        img.convertTo(src, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
+        
+        blockSize = 1 + rng.next() % 5;
+        apertureSize = 1 + 2 * (rng.next() % 4);        
+        k = rng.uniform(0.1, 0.9);
+
+        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderTypes[borderTypeIdx]);
+    }
+};
+
+TEST_P(CornerHarris, Accuracy)
+{
+    const char* borderTypeStr = borderTypes_str[borderTypeIdx];
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(borderTypeStr);
+    PRINT_PARAM(blockSize);
+    PRINT_PARAM(apertureSize);
+    PRINT_PARAM(k);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::cornerHarris(cv::gpu::GpuMat(src), dev_dst, blockSize, apertureSize, k, borderTypes[borderTypeIdx]);
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, CornerHarris, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_32FC1), 
+                        testing::Values(0, 4)));
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// cornerMinEigen
+
+struct CornerMinEigen : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int borderTypeIdx;
+
+    cv::Mat src;
+    int blockSize;
+    int apertureSize;
+
+    cv::Mat dst_gold;
+    
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        borderTypeIdx = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());        
+    
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+        
+        cv::Mat img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);
+        ASSERT_FALSE(img.empty());
+
+        img.convertTo(src, type, type == CV_32F ? 1.0 / 255.0 : 1.0);
+        
+        blockSize = 1 + rng.next() % 5;
+        apertureSize = 1 + 2 * (rng.next() % 4);
+
+        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderTypes[borderTypeIdx]);
+    }
+};
+
+TEST_P(CornerMinEigen, Accuracy)
+{
+    const char* borderTypeStr = borderTypes_str[borderTypeIdx];
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(borderTypeStr);
+    PRINT_PARAM(blockSize);
+    PRINT_PARAM(apertureSize);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::cornerMinEigenVal(cv::gpu::GpuMat(src), dev_dst, blockSize, apertureSize, borderTypes[borderTypeIdx]);
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-2);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, CornerMinEigen, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(CV_8UC1, CV_32FC1), 
+                        testing::Values(0, 4)));
+
+////////////////////////////////////////////////////////////////////////
+// ColumnSum
+
+struct ColumnSum : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Size size;
+    cv::Mat src;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 400), rng.uniform(100, 400));
+
+        src = cvtest::randomMat(rng, size, CV_32F, 0.0, 1.0, false);
+    }
+};
+
+TEST_P(ColumnSum, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::columnSum(cv::gpu::GpuMat(src), dev_dst);
+        dev_dst.download(dst);
+    );
+
+    for (int j = 0; j < src.cols; ++j)
+    {
+        float gold = src.at<float>(0, j);
+        float res = dst.at<float>(0, j);
+        ASSERT_NEAR(res, gold, 0.5);
+    }
+
+    for (int i = 1; i < src.rows; ++i)
+    {
+        for (int j = 0; j < src.cols; ++j)
+        {
+            float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
+            float res = dst.at<float>(i, j);
+            ASSERT_NEAR(res, gold, 0.5);
+        }
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, ColumnSum, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////////////////////
+// Norm
+
+static const int normTypes[] = {cv::NORM_INF, cv::NORM_L1, cv::NORM_L2};
+static const char* normTypes_str[] = {"NORM_INF", "NORM_L1", "NORM_L2"};
+
+struct Norm : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+    int normTypeIdx;
+
+    cv::Size size;
+    cv::Mat src;
+
+    double gold;
+
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+        normTypeIdx = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 400), rng.uniform(100, 400));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 10.0, false);
+
+        gold = cv::norm(src, normTypes[normTypeIdx]);
+    }
+};
+
+TEST_P(Norm, Accuracy)
+{
+    const char* normTypeStr = normTypes_str[normTypeIdx];
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+    PRINT_PARAM(normTypeStr);
+
+    double res;
+
+    ASSERT_NO_THROW(
+        res = cv::gpu::norm(cv::gpu::GpuMat(src), normTypes[normTypeIdx]);
+    );
+
+    ASSERT_NEAR(res, gold, 0.5);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Norm, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(types(CV_8U, CV_32F, 1, 1)),
+                        testing::Range(0, 3)));
+
+////////////////////////////////////////////////////////////////////////////////
+// reprojectImageTo3D
+
+struct ReprojectImageTo3D : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::Size size;
+    cv::Mat disp;
+    cv::Mat Q;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(100, 500), rng.uniform(100, 500));
+
+        disp = cvtest::randomMat(rng, size, CV_8UC1, 5.0, 30.0, false);
+
+        Q = cvtest::randomMat(rng, cv::Size(4, 4), CV_32FC1, 0.1, 1.0, false);
+
+        cv::reprojectImageTo3D(disp, dst_gold, Q, false);
+    }
+};
+
+TEST_P(ReprojectImageTo3D, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat gpures;
+        cv::gpu::reprojectImageTo3D(cv::gpu::GpuMat(disp), gpures, Q);
+        gpures.download(dst);
+    );
+
+    ASSERT_EQ(dst_gold.size(), dst.size());
+
+    for (int y = 0; y < dst_gold.rows; ++y)
+    {
+        const cv::Vec3f* cpu_row = dst_gold.ptr<cv::Vec3f>(y);
+        const cv::Vec4f* gpu_row = dst.ptr<cv::Vec4f>(y);
+
+        for (int x = 0; x < dst_gold.cols; ++x)
+        {
+            cv::Vec3f gold = cpu_row[x];
+            cv::Vec4f res = gpu_row[x];
+
+            ASSERT_NEAR(res[0], gold[0], 1e-5);
+            ASSERT_NEAR(res[1], gold[1], 1e-5);
+            ASSERT_NEAR(res[2], gold[2], 1e-5);
+        }
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, ReprojectImageTo3D, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////////////////////////////
+// meanShift
+
+struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat rgba;
+
+    int spatialRad;
+    int colorRad;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("meanshift/cones.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, rgba, CV_BGR2BGRA);
+
+        spatialRad = 30;
+        colorRad = 30;
+    }
+};
+
+TEST_P(MeanShift, Filtering)
+{
+    cv::Mat img_template;
+    
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        img_template = readImage("meanshift/con_result.png");
+    else
+        img_template = readImage("meanshift/con_result_CC1X.png");
+
+    ASSERT_FALSE(img_template.empty());
+
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::meanShiftFiltering(cv::gpu::GpuMat(rgba), dev_dst, spatialRad, colorRad);
+        dev_dst.download(dst);
+    );
+
+    ASSERT_EQ(CV_8UC4, dst.type());
+
+    cv::Mat result;
+    cv::cvtColor(dst, result, CV_BGRA2BGR);
+
+    EXPECT_MAT_NEAR(img_template, result, 0.0);
+}
+
+TEST_P(MeanShift, Proc)
+{
+    cv::Mat spmap_template;
+    cv::FileStorage fs;
+
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+    else
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+
+    ASSERT_TRUE(fs.isOpened());
+
+    fs["spmap"] >> spmap_template;
+
+    ASSERT_TRUE(!rgba.empty() && !spmap_template.empty());
+
+    PRINT_PARAM(devInfo);
+
+    cv::Mat rmap_filtered;
+    cv::Mat rmap;
+    cv::Mat spmap;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_rmap_filtered;
+        cv::gpu::meanShiftFiltering(cv::gpu::GpuMat(rgba), d_rmap_filtered, spatialRad, colorRad);
+
+        cv::gpu::GpuMat d_rmap;
+        cv::gpu::GpuMat d_spmap;
+        cv::gpu::meanShiftProc(cv::gpu::GpuMat(rgba), d_rmap, d_spmap, spatialRad, colorRad);
+
+        d_rmap_filtered.download(rmap_filtered);
+        d_rmap.download(rmap);
+        d_spmap.download(spmap);
+    );
+
+    ASSERT_EQ(CV_8UC4, rmap.type());
+    
+    EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);    
+    EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShift, testing::ValuesIn(devices()));
+
+struct MeanShiftSegmentation : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int minsize;
+    
+    cv::Mat rgba;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        minsize = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("meanshift/cones.png");
+        ASSERT_FALSE(img.empty());
+        
+        cv::cvtColor(img, rgba, CV_BGR2BGRA);
+
+        std::ostringstream path;
+        path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            path << ".png";
+        else
+            path << "_CC1X.png";
+
+        dst_gold = readImage(path.str());
+        ASSERT_FALSE(dst_gold.empty());
+    }
+};
+
+TEST_P(MeanShiftSegmentation, Regression)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(minsize);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::meanShiftSegmentation(cv::gpu::GpuMat(rgba), dst, 10, 10, minsize);
+    );
+
+    cv::Mat dst_rgb;
+    cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+
+    EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MeanShiftSegmentation, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(0, 4, 20, 84, 340, 1364)));
+
+////////////////////////////////////////////////////////////////////////////////
+// matchTemplate
+
+static const char* matchTemplateMethods[] = {"SQDIFF", "SQDIFF_NORMED", "CCORR", "CCORR_NORMED", "CCOEFF", "CCOEFF_NORMED"};
+
+struct MatchTemplate8U : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int cn;
+    int method;
+
+    int n, m, h, w;
+    cv::Mat image, templ;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        cn = std::tr1::get<1>(GetParam());
+        method = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        n = rng.uniform(30, 100);
+        m = rng.uniform(30, 100);
+        h = rng.uniform(5, n - 1);
+        w = rng.uniform(5, m - 1);
+
+        image = cvtest::randomMat(rng, cv::Size(m, n), CV_MAKETYPE(CV_8U, cn), 1.0, 10.0, false);
+        templ = cvtest::randomMat(rng, cv::Size(w, h), CV_MAKETYPE(CV_8U, cn), 1.0, 10.0, false);
+
+        cv::matchTemplate(image, templ, dst_gold, method);
+    }
+};
+
+TEST_P(MatchTemplate8U, Regression)
+{
+    const char* matchTemplateMethodStr = matchTemplateMethods[method];
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(cn);
+    PRINT_PARAM(matchTemplateMethodStr);
+    PRINT_PARAM(n);
+    PRINT_PARAM(m);
+    PRINT_PARAM(h);
+    PRINT_PARAM(w);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::matchTemplate(cv::gpu::GpuMat(image), cv::gpu::GpuMat(templ), dev_dst, method);
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 5 * h * w * 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate8U, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Range(1, 5), 
+                        testing::Values((int)CV_TM_SQDIFF, (int)CV_TM_SQDIFF_NORMED, (int)CV_TM_CCORR, (int)CV_TM_CCORR_NORMED, (int)CV_TM_CCOEFF, (int)CV_TM_CCOEFF_NORMED)));
+
+struct MatchTemplate32F : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int cn;
+    int method;
+
+    int n, m, h, w;
+    cv::Mat image, templ;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        cn = std::tr1::get<1>(GetParam());
+        method = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        n = rng.uniform(30, 100);
+        m = rng.uniform(30, 100);
+        h = rng.uniform(5, n - 1);
+        w = rng.uniform(5, m - 1);
+
+        image = cvtest::randomMat(rng, cv::Size(m, n), CV_MAKETYPE(CV_32F, cn), 0.001, 1.0, false);
+        templ = cvtest::randomMat(rng, cv::Size(w, h), CV_MAKETYPE(CV_32F, cn), 0.001, 1.0, false);
+
+        cv::matchTemplate(image, templ, dst_gold, method);
+    }
+};
+
+TEST_P(MatchTemplate32F, Regression)
+{
+    const char* matchTemplateMethodStr = matchTemplateMethods[method];
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(cn);
+    PRINT_PARAM(matchTemplateMethodStr);
+    PRINT_PARAM(n);
+    PRINT_PARAM(m);
+    PRINT_PARAM(h);
+    PRINT_PARAM(w);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::matchTemplate(cv::gpu::GpuMat(image), cv::gpu::GpuMat(templ), dev_dst, method);
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.25 * h * w * 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate32F, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Range(1, 5), 
+                        testing::Values((int)CV_TM_SQDIFF, (int)CV_TM_CCORR)));
+
+struct MatchTemplate : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::Mat image;
+    cv::Mat pattern;
+
+    cv::Point maxLocGold;
+
+    cv::gpu::DeviceInfo devInfo;
+    int method;
+
+    virtual void SetUp()
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        method = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        image = readImage("matchtemplate/black.png");
+        ASSERT_FALSE(image.empty());
+        
+        pattern = readImage("matchtemplate/cat.png");
+        ASSERT_FALSE(pattern.empty());
+
+        maxLocGold = cv::Point(284, 12);
+    }
+};
+
+TEST_P(MatchTemplate, FindPatternInBlack)
+{
+    const char* matchTemplateMethodStr = matchTemplateMethods[method];
+
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(matchTemplateMethodStr);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_dst;
+        cv::gpu::matchTemplate(cv::gpu::GpuMat(image), cv::gpu::GpuMat(pattern), dev_dst, method);
+        dev_dst.download(dst);
+    );
+
+    double maxValue;
+    cv::Point maxLoc;
+    cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
+
+    ASSERT_EQ(maxLocGold, maxLoc);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MatchTemplate, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values((int)CV_TM_CCOEFF_NORMED, (int)CV_TM_CCORR_NORMED)));
+
+////////////////////////////////////////////////////////////////////////////
+// MulSpectrums
+
+struct MulSpectrums : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int flag;
+
+    cv::Mat a, b; 
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        flag = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        a = cvtest::randomMat(rng, cv::Size(rng.uniform(100, 200), rng.uniform(100, 200)), CV_32FC2, 0.0, 10.0, false);
+        b = cvtest::randomMat(rng, a.size(), CV_32FC2, 0.0, 10.0, false);
+    }
+};
+
+TEST_P(MulSpectrums, Simple)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(flag);
+
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
+    
+    cv::Mat c;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_c;
+
+        cv::gpu::mulSpectrums(cv::gpu::GpuMat(a), cv::gpu::GpuMat(b), d_c, flag, false);
+
+        d_c.download(c);
+    );
+
+    EXPECT_MAT_NEAR(c_gold, c, 1e-4);
+}
+
+TEST_P(MulSpectrums, Scaled)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(flag);
+
+    float scale = 1.f / a.size().area();
+
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
+    c_gold.convertTo(c_gold, c_gold.type(), scale);
+
+    cv::Mat c;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_c;
+
+        cv::gpu::mulAndScaleSpectrums(cv::gpu::GpuMat(a), cv::gpu::GpuMat(b), d_c, flag, scale, false);
+
+        d_c.download(c);
+    );
+
+    EXPECT_MAT_NEAR(c_gold, c, 1e-4);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, MulSpectrums, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::Values(0, (int)cv::DFT_ROWS)));
+
+////////////////////////////////////////////////////////////////////////////
+// Dft
+
+struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+
+static void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
+{
+    PRINT_PARAM(hint);
+    PRINT_PARAM(cols);
+    PRINT_PARAM(rows);
+    PRINT_PARAM(flags);
+    PRINT_PARAM(inplace);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Mat a = cvtest::randomMat(rng, cv::Size(cols, rows), CV_32FC2, 0.0, 10.0, false);
+
+    cv::Mat b_gold;
+    cv::dft(a, b_gold, flags);
+
+    cv::gpu::GpuMat d_b;
+    cv::gpu::GpuMat d_b_data;
+    if (inplace)
+    {
+        d_b_data.create(1, a.size().area(), CV_32FC2);
+        d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+    }
+    cv::gpu::dft(cv::gpu::GpuMat(a), d_b, cv::Size(cols, rows), flags);
+
+    EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+    ASSERT_EQ(CV_32F, d_b.depth());
+    ASSERT_EQ(2, d_b.channels());
+    EXPECT_MAT_NEAR(b_gold, d_b, rows * cols * 1e-4);
+}
+
+TEST_P(Dft, C2C)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    int cols = 2 + rng.next() % 100, rows = 2 + rng.next() % 100;
+
+    ASSERT_NO_THROW(
+        for (int i = 0; i < 2; ++i)
+        {
+            bool inplace = i != 0;
+
+            testC2C("no flags", cols, rows, 0, inplace);
+            testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+            testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+            testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+            testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+            testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+            testC2C("single col", 1, rows, 0, inplace);
+            testC2C("single row", cols, 1, 0, inplace);
+            testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+            testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+            testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+            testC2C("size 1 2", 1, 2, 0, inplace);
+            testC2C("size 2 1", 2, 1, 0, inplace);
+        }
+    );
+}
+
+static void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
+{
+    PRINT_PARAM(hint);
+    PRINT_PARAM(cols);
+    PRINT_PARAM(rows);
+    PRINT_PARAM(inplace);
+    
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Mat a = cvtest::randomMat(rng, cv::Size(cols, rows), CV_32FC1, 0.0, 10.0, false);
+
+    cv::gpu::GpuMat d_b, d_c;
+    cv::gpu::GpuMat d_b_data, d_c_data;
+    if (inplace)
+    {
+        if (a.cols == 1)
+        {
+            d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
+            d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+        }
+        else
+        {
+            d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
+            d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
+        }
+        d_c_data.create(1, a.size().area(), CV_32F);
+        d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
+    }
+
+    cv::gpu::dft(cv::gpu::GpuMat(a), d_b, cv::Size(cols, rows), 0);
+    cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
+    
+    EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+    EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
+    ASSERT_EQ(CV_32F, d_c.depth());
+    ASSERT_EQ(1, d_c.channels());
+
+    cv::Mat c(d_c);
+    EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
+}
+
+TEST_P(Dft, R2CThenC2R)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    int cols = 2 + rng.next() % 100, rows = 2 + rng.next() % 100;
+
+    ASSERT_NO_THROW(
+        testR2CThenC2R("sanity", cols, rows, false);
+        testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+        testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+        testR2CThenC2R("single col", 1, rows, false);
+        testR2CThenC2R("single col 1", 1, rows + 1, false);
+        testR2CThenC2R("single row", cols, 1, false);
+        testR2CThenC2R("single row 1", cols + 1, 1, false);
+
+        testR2CThenC2R("sanity", cols, rows, true);
+        testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+        testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+        testR2CThenC2R("single row", cols, 1, true);
+        testR2CThenC2R("single row 1", cols + 1, 1, true);
+    );
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Dft, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////////////////////////
+// blend
+
+template <typename T> static void blendLinearGold(const cv::Mat& img1, const cv::Mat& img2, const cv::Mat& weights1, const cv::Mat& weights2, cv::Mat& result_gold)
+{
+    result_gold.create(img1.size(), img1.type());
+
+    int cn = img1.channels();
+
+    for (int y = 0; y < img1.rows; ++y)
+    {
+        const float* weights1_row = weights1.ptr<float>(y);
+        const float* weights2_row = weights2.ptr<float>(y);
+        const T* img1_row = img1.ptr<T>(y);
+        const T* img2_row = img2.ptr<T>(y);
+        T* result_gold_row = result_gold.ptr<T>(y);
+        for (int x = 0; x < img1.cols * cn; ++x)
+        {
+            float w1 = weights1_row[x / cn];
+            float w2 = weights2_row[x / cn];
+            result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
+        }
+    }
+}
+
+struct Blend : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int depth;
+    int cn;
+
+    int type;
+    cv::Size size;
+    cv::Mat img1;
+    cv::Mat img2;
+    cv::Mat weights1;
+    cv::Mat weights2;
+
+    cv::Mat result_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        depth = std::tr1::get<1>(GetParam());
+        cn = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        type = CV_MAKETYPE(depth, cn);
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(200 + cvtest::randInt(rng) % 1000, 200 + cvtest::randInt(rng) % 1000);
+
+        img1 = cvtest::randomMat(rng, size, type, 0.0, depth == CV_8U ? 255.0 : 1.0, false);
+        img2 = cvtest::randomMat(rng, size, type, 0.0, depth == CV_8U ? 255.0 : 1.0, false);
+        weights1 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
+        weights2 = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
+        
+        if (depth == CV_8U)
+            blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
+        else
+            blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
+    }
+};
+
+TEST_P(Blend, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat result;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_result;
+
+        cv::gpu::blendLinear(cv::gpu::GpuMat(img1), cv::gpu::GpuMat(img2), cv::gpu::GpuMat(weights1), cv::gpu::GpuMat(weights2), d_result);
+
+        d_result.download(result);
+    );
+
+    EXPECT_MAT_NEAR(result_gold, result, depth == CV_8U ? 1.0 : 1e-5);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Blend, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(CV_8U, CV_32F),
+                        testing::Range(1, 5)));
+
+////////////////////////////////////////////////////////
+// pyrDown
+
+struct PyrDown : testing::TestWithParam<cv::gpu::DeviceInfo>
+{    
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat src;
+    
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobm/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        img.convertTo(src, CV_16S);
+        
+        cv::pyrDown(src, dst_gold);
+    }
+};
+
+TEST_P(PyrDown, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_dst;
+        
+        cv::gpu::pyrDown(cv::gpu::GpuMat(src), d_dst);
+        
+        d_dst.download(dst);
+    );
+
+    ASSERT_EQ(dst_gold.cols, dst.cols);
+    ASSERT_EQ(dst_gold.rows, dst.rows);
+    ASSERT_EQ(dst_gold.type(), dst.type());
+
+    double err = cvtest::crossCorr(dst_gold, dst) /
+            (cv::norm(dst_gold,cv::NORM_L2)*cv::norm(dst,cv::NORM_L2));
+    ASSERT_NEAR(err, 1., 1e-2);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrDown, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////
+// pyrUp
+
+struct PyrUp: testing::TestWithParam<cv::gpu::DeviceInfo>
+{    
+    cv::gpu::DeviceInfo devInfo;
+    
+    cv::Mat src;
+    
+    cv::Mat dst_gold;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::Mat img = readImage("stereobm/aloe-L.png");
+        ASSERT_FALSE(img.empty());
+        
+        img.convertTo(src, CV_16S);
+        
+        cv::pyrUp(src, dst_gold);
+    }
+};
+
+TEST_P(PyrUp, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_dst;
+        
+        cv::gpu::pyrUp(cv::gpu::GpuMat(src), d_dst);
+        
+        d_dst.download(dst);
+    );
+
+    ASSERT_EQ(dst_gold.cols, dst.cols);
+    ASSERT_EQ(dst_gold.rows, dst.rows);
+    ASSERT_EQ(dst_gold.type(), dst.type());
+
+    double err = cvtest::crossCorr(dst_gold, dst) /
+            (cv::norm(dst_gold,cv::NORM_L2)*cv::norm(dst,cv::NORM_L2));
+    ASSERT_NEAR(err, 1., 1e-2);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, PyrUp, testing::ValuesIn(devices()));
+
+////////////////////////////////////////////////////////
+// Canny
+
+struct Canny : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, bool> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int apperture_size;
+    bool L2gradient;
+    
+    cv::Mat img;
+
+    double low_thresh;
+    double high_thresh;
+
+    cv::Mat edges_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        apperture_size = std::tr1::get<1>(GetParam());
+        L2gradient = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        img = readImage("stereobm/aloe-L.png", CV_LOAD_IMAGE_GRAYSCALE);
+        ASSERT_FALSE(img.empty()); 
+
+        low_thresh = 50.0;
+        high_thresh = 100.0;
+        
+        cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, L2gradient);
+    }
+};
+
+TEST_P(Canny, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+    PRINT_PARAM(apperture_size);
+    PRINT_PARAM(L2gradient);
+
+    cv::Mat edges;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat d_edges;
+
+        cv::gpu::Canny(cv::gpu::GpuMat(img), d_edges, low_thresh, high_thresh, apperture_size, L2gradient);
+
+        d_edges.download(edges);
+    );
+
+    EXPECT_MAT_SIMILAR(edges_gold, edges, 1.0);
+}
+
+INSTANTIATE_TEST_CASE_P(ImgProc, Canny, testing::Combine(
+                        testing::ValuesIn(devices()),
+                        testing::Values(3, 5),
+                        testing::Values(false, true)));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_imgproc_gpu.cpp b/modules/gpu/test/test_imgproc_gpu.cpp
deleted file mode 100644
index d45d7c77bb..0000000000
--- a/modules/gpu/test/test_imgproc_gpu.cpp
+++ /dev/null
@@ -1,966 +0,0 @@
-/*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*/
-
-#include <cmath>
-#include <limits>
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace std;
-using namespace gpu;
-
-class CV_GpuImageProcTest : public cvtest::BaseTest
-{
-public:
-    virtual ~CV_GpuImageProcTest() {}
-
-protected:
-    void run(int);
-
-    int test8UC1 (const Mat& img);
-    int test8UC4 (const Mat& img);
-    int test32SC1(const Mat& img);
-    int test32FC1(const Mat& img);
-
-    virtual int test(const Mat& img) = 0;
-
-    int CheckNorm(const Mat& m1, const Mat& m2);
-
-    // Checks whether two images are similar enough using normalized
-    // cross-correlation as an error measure
-    int CheckSimilarity(const Mat& m1, const Mat& m2, float max_err=1e-3f);
-};
-
-
-int CV_GpuImageProcTest::test8UC1(const Mat& img)
-{
-    cv::Mat img_C1;
-    cvtColor(img, img_C1, CV_BGR2GRAY);
-
-    return test(img_C1);
-}
-
-int CV_GpuImageProcTest::test8UC4(const Mat& img)
-{
-    cv::Mat img_C4;
-    cvtColor(img, img_C4, CV_BGR2BGRA);
-
-    return test(img_C4);
-}
-
-int CV_GpuImageProcTest::test32SC1(const Mat& img)
-{
-    cv::Mat img_C1;
-    cvtColor(img, img_C1, CV_BGR2GRAY);
-    img_C1.convertTo(img_C1, CV_32S);
-
-    return test(img_C1);
-}
-
-int CV_GpuImageProcTest::test32FC1(const Mat& img)
-{
-    cv::Mat temp, img_C1;
-    img.convertTo(temp, CV_32F, 1.f / 255.f);
-    cvtColor(temp, img_C1, CV_BGR2GRAY);
-
-    return test(img_C1);
-}
-
-int CV_GpuImageProcTest::CheckNorm(const Mat& m1, const Mat& m2)
-{
-    double ret = norm(m1, m2, NORM_INF);
-
-    if (ret < std::numeric_limits<double>::epsilon())
-    {
-        return cvtest::TS::OK;
-    }
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "Norm: %f\n", ret);
-        return cvtest::TS::FAIL_GENERIC;
-    }
-}
-
-int CV_GpuImageProcTest::CheckSimilarity(const Mat& m1, const Mat& m2, float max_err)
-{
-    Mat diff;
-    cv::matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
-
-    float err = abs(diff.at<float>(0, 0) - 1.f);
-
-    if (err > max_err)
-        return cvtest::TS::FAIL_INVALID_OUTPUT;
-
-    return cvtest::TS::OK;
-}
-
-void CV_GpuImageProcTest::run( int )
-{
-    //load image
-    cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
-
-    if (img.empty())
-    {
-        ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-        return;
-    }
-
-    int testResult = cvtest::TS::OK;
-    //run tests
-    ts->printf(cvtest::TS::LOG, "\n========Start test 8UC1========\n");
-    if (test8UC1(img) == cvtest::TS::OK)
-        ts->printf(cvtest::TS::LOG, "SUCCESS\n");
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "FAIL\n");
-        testResult = cvtest::TS::FAIL_GENERIC;
-    }
-
-    ts->printf(cvtest::TS::LOG, "\n========Start test 8UC4========\n");
-    if (test8UC4(img) == cvtest::TS::OK)
-        ts->printf(cvtest::TS::LOG, "SUCCESS\n");
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "FAIL\n");
-        testResult = cvtest::TS::FAIL_GENERIC;
-    }
-
-    ts->printf(cvtest::TS::LOG, "\n========Start test 32SC1========\n");
-    if (test32SC1(img) == cvtest::TS::OK)
-        ts->printf(cvtest::TS::LOG, "SUCCESS\n");
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "FAIL\n");
-        testResult = cvtest::TS::FAIL_GENERIC;
-    }
-
-    ts->printf(cvtest::TS::LOG, "\n========Start test 32FC1========\n");
-    if (test32FC1(img) == cvtest::TS::OK)
-        ts->printf(cvtest::TS::LOG, "SUCCESS\n");
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "FAIL\n");
-        testResult = cvtest::TS::FAIL_GENERIC;
-    }
-
-    ts->set_failed_test_info(testResult);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// threshold
-struct CV_GpuImageThresholdTest : public CV_GpuImageProcTest
-{
-public:
-    CV_GpuImageThresholdTest() {}
-
-    int test(const Mat& img)
-    {
-        if (img.type() != CV_8UC1 && img.type() != CV_32FC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        const double maxVal = img.type() == CV_8UC1 ? 255 : 1.0;
-
-        cv::RNG& rng = ts->get_rng();
-
-        int res = cvtest::TS::OK;
-
-        for (int type = THRESH_BINARY; type <= THRESH_TOZERO_INV; ++type)
-        {
-            const double thresh = rng.uniform(0.0, maxVal);
-
-            cv::Mat cpuRes;
-            cv::threshold(img, cpuRes, thresh, maxVal, type);
-
-            GpuMat gpu1(img);
-            GpuMat gpuRes;
-            cv::gpu::threshold(gpu1, gpuRes, thresh, maxVal, type);
-
-            if (CheckNorm(cpuRes, gpuRes) != cvtest::TS::OK)
-                res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// resize
-struct CV_GpuNppImageResizeTest : public CV_GpuImageProcTest
-{
-    CV_GpuNppImageResizeTest() {}
-    int test(const Mat& img)
-    {
-        if (img.type() != CV_8UC1 && img.type() != CV_8UC4)
-        {
-            ts->printf(cvtest::TS::LOG, "Unsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        int interpolations[] = {INTER_NEAREST, INTER_LINEAR, /*INTER_CUBIC,*/ /*INTER_LANCZOS4*/};
-        const char* interpolations_str[] = {"INTER_NEAREST", "INTER_LINEAR", /*"INTER_CUBIC",*/ /*"INTER_LANCZOS4"*/};
-        int interpolations_num = sizeof(interpolations) / sizeof(int);
-
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < interpolations_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "Interpolation: %s\n", interpolations_str[i]);
-
-            Mat cpu_res1, cpu_res2;
-            cv::resize(img, cpu_res1, Size(), 2.0, 2.0, interpolations[i]);
-            cv::resize(cpu_res1, cpu_res2, Size(), 0.5, 0.5, interpolations[i]);
-
-            GpuMat gpu1(img), gpu_res1, gpu_res2;
-            cv::gpu::resize(gpu1, gpu_res1, Size(), 2.0, 2.0, interpolations[i]);
-            cv::gpu::resize(gpu_res1, gpu_res2, Size(), 0.5, 0.5, interpolations[i]);
-
-            if (CheckSimilarity(cpu_res2, gpu_res2) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// copyMakeBorder
-struct CV_GpuNppImageCopyMakeBorderTest : public CV_GpuImageProcTest
-{
-    CV_GpuNppImageCopyMakeBorderTest() {}
-
-    int test(const Mat& img)
-    {
-        if (img.type() != CV_8UC1 && img.type() != CV_8UC4 && img.type() != CV_32SC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        cv::RNG& rng = ts->get_rng();
-        int top = rng.uniform(1, 10);
-        int botton = rng.uniform(1, 10);
-        int left = rng.uniform(1, 10);
-        int right = rng.uniform(1, 10);
-        cv::Scalar val(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
-
-        Mat cpudst;
-        cv::copyMakeBorder(img, cpudst, top, botton, left, right, BORDER_CONSTANT, val);
-
-        GpuMat gpu1(img);
-        GpuMat gpudst;
-        cv::gpu::copyMakeBorder(gpu1, gpudst, top, botton, left, right, val);
-
-        return CheckNorm(cpudst, gpudst);
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// warpAffine
-struct CV_GpuNppImageWarpAffineTest : public CV_GpuImageProcTest
-{
-    CV_GpuNppImageWarpAffineTest() {}
-
-    int test(const Mat& img)
-    {
-        if (img.type() == CV_32SC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        static double reflect[2][3] = { {-1, 0, 0},
-                                        { 0, -1, 0} };
-        reflect[0][2] = img.cols;
-        reflect[1][2] = img.rows;
-
-        Mat M(2, 3, CV_64F, (void*)reflect);
-
-        int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP};
-        const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"};
-        int flags_num = sizeof(flags) / sizeof(int);
-
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < flags_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nFlags: %s\n", flags_str[i]);
-
-            Mat cpudst;
-            cv::warpAffine(img, cpudst, M, img.size(), flags[i]);
-
-            GpuMat gpu1(img);
-            GpuMat gpudst;
-            cv::gpu::warpAffine(gpu1, gpudst, M, gpu1.size(), flags[i]);
-
-            // Check inner parts (ignoring 1 pixel width border)
-            if (CheckSimilarity(cpudst.rowRange(1, cpudst.rows - 1).colRange(1, cpudst.cols - 1),
-                                gpudst.rowRange(1, gpudst.rows - 1).colRange(1, gpudst.cols - 1)) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// warpPerspective
-struct CV_GpuNppImageWarpPerspectiveTest : public CV_GpuImageProcTest
-{
-    CV_GpuNppImageWarpPerspectiveTest() {}
-
-
-    int test(const Mat& img)
-    {
-        if (img.type() == CV_32SC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        static double reflect[3][3] = { { -1, 0, 0},
-                                        { 0, -1, 0},
-                                        { 0, 0, 1 }};
-        reflect[0][2] = img.cols;
-        reflect[1][2] = img.rows;
-        Mat M(3, 3, CV_64F, (void*)reflect);
-
-        int flags[] = {INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, INTER_NEAREST | WARP_INVERSE_MAP, INTER_LINEAR | WARP_INVERSE_MAP, INTER_CUBIC | WARP_INVERSE_MAP};
-        const char* flags_str[] = {"INTER_NEAREST", "INTER_LINEAR", "INTER_CUBIC", "INTER_NEAREST | WARP_INVERSE_MAP", "INTER_LINEAR | WARP_INVERSE_MAP", "INTER_CUBIC | WARP_INVERSE_MAP"};
-        int flags_num = sizeof(flags) / sizeof(int);
-
-        int test_res = cvtest::TS::OK;
-
-        for (int i = 0; i < flags_num; ++i)
-        {
-            ts->printf(cvtest::TS::LOG, "\nFlags: %s\n", flags_str[i]);
-
-            Mat cpudst;
-            cv::warpPerspective(img, cpudst, M, img.size(), flags[i]);
-
-            GpuMat gpu1(img);
-            GpuMat gpudst;
-            cv::gpu::warpPerspective(gpu1, gpudst, M, gpu1.size(), flags[i]);
-
-            // Check inner parts (ignoring 1 pixel width border)
-            if (CheckSimilarity(cpudst.rowRange(1, cpudst.rows - 1).colRange(1, cpudst.cols - 1),
-                                gpudst.rowRange(1, gpudst.rows - 1).colRange(1, gpudst.cols - 1)) != cvtest::TS::OK)
-                test_res = cvtest::TS::FAIL_GENERIC;
-        }
-
-        return test_res;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// integral
-struct CV_GpuNppImageIntegralTest : public CV_GpuImageProcTest
-{
-    CV_GpuNppImageIntegralTest() {}
-
-    int test(const Mat& img)
-    {
-        if (img.type() != CV_8UC1)
-        {
-            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-            return cvtest::TS::OK;
-        }
-
-        Mat cpusum;
-        cv::integral(img, cpusum, CV_32S);
-
-        GpuMat gpu1(img);
-        GpuMat gpusum;
-        cv::gpu::integral(gpu1, gpusum);
-
-        return CheckNorm(cpusum, gpusum) == cvtest::TS::OK ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Canny
-//struct CV_GpuNppImageCannyTest : public CV_GpuImageProcTest
-//{
-//    CV_GpuNppImageCannyTest() : CV_GpuImageProcTest( "GPU-NppImageCanny", "Canny" ) {}
-//
-//    int test(const Mat& img)
-//    {
-//        if (img.type() != CV_8UC1)
-//        {
-//            ts->printf(cvtest::TS::LOG, "\nUnsupported type\n");
-//            return cvtest::TS::OK;
-//        }
-//
-//        const double threshold1 = 1.0, threshold2 = 10.0;
-//
-//        Mat cpudst;
-//        cv::Canny(img, cpudst, threshold1, threshold2);
-//
-//        GpuMat gpu1(img);
-//        GpuMat gpudst;
-//        cv::gpu::Canny(gpu1, gpudst, threshold1, threshold2);
-//
-//        return CheckNorm(cpudst, gpudst);
-//    }
-//};
-
-////////////////////////////////////////////////////////////////////////////////
-// cvtColor
-class CV_GpuCvtColorTest : public cvtest::BaseTest
-{
-public:
-    CV_GpuCvtColorTest() {}
-    ~CV_GpuCvtColorTest() {};
-
-protected:
-    void run(int);
-
-    int CheckNorm(const Mat& m1, const Mat& m2);
-};
-
-
-int CV_GpuCvtColorTest::CheckNorm(const Mat& m1, const Mat& m2)
-{
-    float max_err = 1e-2f;
-
-    Mat diff;
-    cv::matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
-
-    float err = abs(diff.at<float>(0, 0) - 1.f);
-
-    if (err > max_err)
-        return cvtest::TS::FAIL_INVALID_OUTPUT;
-
-    return cvtest::TS::OK;
-}
-
-void CV_GpuCvtColorTest::run( int )
-{
-    cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
-
-    if (img.empty())
-    {
-        ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-        return;
-    }
-
-    int testResult = cvtest::TS::OK;
-    cv::Mat cpuRes;
-    cv::gpu::GpuMat gpuImg(img), gpuRes;
-
-    int codes[] = { CV_BGR2RGB, CV_RGB2BGRA, CV_BGRA2RGB,
-                    CV_RGB2BGR555, CV_BGR5552BGR, CV_BGR2BGR565, CV_BGR5652RGB,
-                    CV_RGB2YCrCb, CV_YCrCb2BGR, CV_BGR2YUV, CV_YUV2RGB,
-                    CV_RGB2XYZ, CV_XYZ2BGR, CV_BGR2XYZ, CV_XYZ2RGB,
-                    CV_RGB2HSV, CV_HSV2BGR, CV_BGR2HSV_FULL, CV_HSV2RGB_FULL,
-                    CV_RGB2HLS, CV_HLS2BGR, CV_BGR2HLS_FULL, CV_HLS2RGB_FULL,
-                    CV_RGB2GRAY, CV_GRAY2BGRA, CV_BGRA2GRAY,
-                    CV_GRAY2BGR555, CV_BGR5552GRAY, CV_GRAY2BGR565, CV_BGR5652GRAY};
-    const char* codes_str[] = { "CV_BGR2RGB", "CV_RGB2BGRA", "CV_BGRA2RGB",
-                                "CV_RGB2BGR555", "CV_BGR5552BGR", "CV_BGR2BGR565", "CV_BGR5652RGB",
-                                "CV_RGB2YCrCb", "CV_YCrCb2BGR", "CV_BGR2YUV", "CV_YUV2RGB",
-                                "CV_RGB2XYZ", "CV_XYZ2BGR", "CV_BGR2XYZ", "CV_XYZ2RGB",
-                                "CV_RGB2HSV", "CV_HSV2RGB", "CV_BGR2HSV_FULL", "CV_HSV2RGB_FULL",
-                                "CV_RGB2HLS", "CV_HLS2RGB", "CV_BGR2HLS_FULL", "CV_HLS2RGB_FULL",
-                                "CV_RGB2GRAY", "CV_GRAY2BGRA", "CV_BGRA2GRAY",
-                                "CV_GRAY2BGR555", "CV_BGR5552GRAY", "CV_GRAY2BGR565", "CV_BGR5652GRAY"};
-    int codes_num = sizeof(codes) / sizeof(int);
-
-    for (int i = 0; i < codes_num; ++i)
-    {
-        ts->printf(cvtest::TS::LOG, "\n%s\n", codes_str[i]);
-
-        cv::cvtColor(img, cpuRes, codes[i]);
-        cv::gpu::cvtColor(gpuImg, gpuRes, codes[i]);
-
-        if (CheckNorm(cpuRes, gpuRes) == cvtest::TS::OK)
-            ts->printf(cvtest::TS::LOG, "\nSUCCESS\n");
-        else
-        {
-            ts->printf(cvtest::TS::LOG, "\nFAIL\n");
-            testResult = cvtest::TS::FAIL_GENERIC;
-        }
-
-        img = cpuRes;
-        gpuImg = gpuRes;
-    }
-
-    ts->set_failed_test_info(testResult);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Histograms
-class CV_GpuHistogramsTest : public cvtest::BaseTest
-{
-public:
-    CV_GpuHistogramsTest() {}
-    ~CV_GpuHistogramsTest() {};
-
-protected:
-    void run(int);
-
-    int CheckNorm(const Mat& m1, const Mat& m2)
-    {
-        double ret = norm(m1, m2, NORM_INF);
-
-        if (ret < std::numeric_limits<double>::epsilon())
-        {
-            return cvtest::TS::OK;
-        }
-        else
-        {
-            ts->printf(cvtest::TS::LOG, "\nNorm: %f\n", ret);
-            return cvtest::TS::FAIL_GENERIC;
-        }
-    }
-};
-
-void CV_GpuHistogramsTest::run( int )
-{
-    //load image
-    cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
-
-    if (img.empty())
-    {
-        ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-        return;
-    }
-
-    Mat hsv;
-    cv::cvtColor(img, hsv, CV_BGR2HSV);
-
-    int hbins = 30;
-    int histSize[] = {hbins};
-
-    float hranges[] = {0, 180};
-    const float* ranges[] = {hranges};
-
-    MatND hist;
-
-    int channels[] = {0};
-    calcHist(&hsv, 1, channels, Mat(), hist, 1, histSize, ranges);
-
-    GpuMat gpuHsv(hsv);
-    std::vector<GpuMat> srcs;
-    cv::gpu::split(gpuHsv, srcs);
-    GpuMat gpuHist;
-    histEven(srcs[0], gpuHist, hbins, (int)hranges[0], (int)hranges[1]);
-
-    Mat cpuHist = hist;
-    cpuHist = cpuHist.t();
-    cpuHist.convertTo(cpuHist, CV_32S);
-
-    ts->set_failed_test_info(CheckNorm(cpuHist, gpuHist));
-}
-
-////////////////////////////////////////////////////////////////////////
-// Corner Harris feature detector
-
-struct CV_GpuCornerHarrisTest: cvtest::BaseTest
-{
-    CV_GpuCornerHarrisTest() {}
-
-    void run(int)
-    {
-        for (int i = 0; i < 5; ++i)
-        {
-            int rows = 25 + rand() % 300, cols = 25 + rand() % 300;
-            if (!compareToCpuTest(rows, cols, CV_32F, 1 + rand() % 5, 1 + 2 * (rand() % 4))) return;
-            if (!compareToCpuTest(rows, cols, CV_32F, 1 + rand() % 5, -1)) return;
-            if (!compareToCpuTest(rows, cols, CV_8U, 1 + rand() % 5, 1 + 2 * (rand() % 4))) return;
-            if (!compareToCpuTest(rows, cols, CV_8U, 1 + rand() % 5, -1)) return;
-        }
-    }
-
-    bool compareToCpuTest(int rows, int cols, int depth, int blockSize, int apertureSize)
-    {
-        RNG rng;
-        cv::Mat src(rows, cols, depth);
-        if (depth == CV_32F)
-            rng.fill(src, RNG::UNIFORM, cv::Scalar(0), cv::Scalar(1));
-        else if (depth == CV_8U)
-            rng.fill(src, RNG::UNIFORM, cv::Scalar(0), cv::Scalar(256));
-
-        double k = 0.1;
-
-        cv::Mat dst_gold;
-        cv::gpu::GpuMat dst;
-        cv::Mat dsth;
-        int borderType;
-
-        borderType = BORDER_REFLECT101;
-        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
-        cv::gpu::cornerHarris(cv::gpu::GpuMat(src), dst, blockSize, apertureSize, k, borderType);
-
-        dsth = dst;
-        for (int i = 0; i < dst.rows; ++i)
-        {
-            for (int j = 0; j < dst.cols; ++j)
-            {
-                float a = dst_gold.at<float>(i, j);
-                float b = dsth.at<float>(i, j);
-                if (fabs(a - b) > 1e-3f)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "%d %d %f %f %d\n", i, j, a, b, apertureSize);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                };
-            }
-        }
-
-        borderType = BORDER_REPLICATE;
-        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
-        cv::gpu::cornerHarris(cv::gpu::GpuMat(src), dst, blockSize, apertureSize, k, borderType);
-
-        dsth = dst;
-        for (int i = 0; i < dst.rows; ++i)
-        {
-            for (int j = 0; j < dst.cols; ++j)
-            {
-                float a = dst_gold.at<float>(i, j);
-                float b = dsth.at<float>(i, j);
-                if (fabs(a - b) > 1e-3f)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "%d %d %f %f %d\n", i, j, a, b, apertureSize);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                };
-            }
-        }
-        return true;
-    }
-};
-
-////////////////////////////////////////////////////////////////////////
-// Corner Min Eigen Val
-
-struct CV_GpuCornerMinEigenValTest: cvtest::BaseTest
-{
-    CV_GpuCornerMinEigenValTest() {}
-
-    void run(int)
-    {
-        for (int i = 0; i < 3; ++i)
-        {
-            int rows = 25 + rand() % 300, cols = 25 + rand() % 300;
-            if (!compareToCpuTest(rows, cols, CV_32F, 1 + rand() % 5, -1)) return;
-            if (!compareToCpuTest(rows, cols, CV_32F, 1 + rand() % 5, 1 + 2 * (rand() % 4))) return;
-            if (!compareToCpuTest(rows, cols, CV_8U, 1 + rand() % 5, -1)) return;
-            if (!compareToCpuTest(rows, cols, CV_8U, 1 + rand() % 5, 1 + 2 * (rand() % 4))) return;
-        }
-    }
-
-    bool compareToCpuTest(int rows, int cols, int depth, int blockSize, int apertureSize)
-    {
-        RNG rng;
-        cv::Mat src(rows, cols, depth);
-        if (depth == CV_32F)
-            rng.fill(src, RNG::UNIFORM, cv::Scalar(0), cv::Scalar(1));
-        else if (depth == CV_8U)
-            rng.fill(src, RNG::UNIFORM, cv::Scalar(0), cv::Scalar(256));
-
-        cv::Mat dst_gold;
-        cv::gpu::GpuMat dst;
-        cv::Mat dsth;
-
-        int borderType;
-
-        borderType = BORDER_REFLECT101;
-        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
-        cv::gpu::cornerMinEigenVal(cv::gpu::GpuMat(src), dst, blockSize, apertureSize, borderType);
-
-        dsth = dst;
-        for (int i = 0; i < dst.rows; ++i)
-        {
-            for (int j = 0; j < dst.cols; ++j)
-            {
-                float a = dst_gold.at<float>(i, j);
-                float b = dsth.at<float>(i, j);
-                if (fabs(a - b) > 1e-2f)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "%d %d %f %f %d %d\n", i, j, a, b, apertureSize, blockSize);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                };
-            }
-        }
-
-        borderType = BORDER_REPLICATE;
-        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
-        cv::gpu::cornerMinEigenVal(cv::gpu::GpuMat(src), dst, blockSize, apertureSize, borderType);
-
-        dsth = dst;
-        for (int i = 0; i < dst.rows; ++i)
-        {
-            for (int j = 0; j < dst.cols; ++j)
-            {
-                float a = dst_gold.at<float>(i, j);
-                float b = dsth.at<float>(i, j);
-                if (fabs(a - b) > 1e-2f)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "%d %d %f %f %d %d\n", i, j, a, b, apertureSize, blockSize);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return false;
-                };
-            }
-        }
-
-        return true;
-    }
-};
-
-struct CV_GpuColumnSumTest: cvtest::BaseTest
-{
-    CV_GpuColumnSumTest() {}
-
-    void run(int)
-    {
-        int cols = 375;
-        int rows = 1072;
-
-        Mat src(rows, cols, CV_32F);
-        RNG rng(1);
-        rng.fill(src, RNG::UNIFORM, Scalar(0), Scalar(1));
-
-        GpuMat d_dst;
-        columnSum(GpuMat(src), d_dst);
-
-        Mat dst = d_dst;
-        for (int j = 0; j < src.cols; ++j)
-        {
-            float a = src.at<float>(0, j);
-            float b = dst.at<float>(0, j);
-            if (fabs(a - b) > 0.5f)
-            {
-                ts->printf(cvtest::TS::CONSOLE, "big diff at %d %d: %f %f\n", 0, j, a, b);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-        }
-        for (int i = 1; i < src.rows; ++i)
-        {
-            for (int j = 0; j < src.cols; ++j)
-            {
-                float a = src.at<float>(i, j) += src.at<float>(i - 1, j);
-                float b = dst.at<float>(i, j);
-                if (fabs(a - b) > 0.5f)
-                {
-                    ts->printf(cvtest::TS::CONSOLE, "big diff at %d %d: %f %f\n", i, j, a, b);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-            }
-        }
-    }
-};
-
-struct CV_GpuNormTest : cvtest::BaseTest
-{
-    CV_GpuNormTest() {}
-
-    void run(int)
-    {
-        RNG rng(0);
-
-        int rows = rng.uniform(1, 500);
-        int cols = rng.uniform(1, 500);
-
-        for (int cn = 1; cn <= 4; ++cn)
-        {
-            test(NORM_L1, rows, cols, CV_8U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_L1, rows, cols, CV_8S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L1, rows, cols, CV_16U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_L1, rows, cols, CV_16S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L1, rows, cols, CV_32S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L1, rows, cols, CV_32F, cn, Scalar::all(0), Scalar::all(1));
-
-            test(NORM_L2, rows, cols, CV_8U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_L2, rows, cols, CV_8S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L2, rows, cols, CV_16U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_L2, rows, cols, CV_16S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L2, rows, cols, CV_32S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_L2, rows, cols, CV_32F, cn, Scalar::all(0), Scalar::all(1));
-
-            test(NORM_INF, rows, cols, CV_8U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_INF, rows, cols, CV_8S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_INF, rows, cols, CV_16U, cn, Scalar::all(0), Scalar::all(10));
-            test(NORM_INF, rows, cols, CV_16S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_INF, rows, cols, CV_32S, cn, Scalar::all(-10), Scalar::all(10));
-            test(NORM_INF, rows, cols, CV_32F, cn, Scalar::all(0), Scalar::all(1));
-        }
-    }
-
-    void gen(Mat& mat, int rows, int cols, int type, Scalar low, Scalar high)
-    {
-        mat.create(rows, cols, type);
-        RNG rng(0);
-        rng.fill(mat, RNG::UNIFORM, low, high);
-    }
-
-    void test(int norm_type, int rows, int cols, int depth, int cn, Scalar low, Scalar high)
-    {
-        int type = CV_MAKE_TYPE(depth, cn);
-
-        Mat src;
-        gen(src, rows, cols, type, low, high);
-
-        double gold = norm(src, norm_type);
-        double mine = norm(GpuMat(src), norm_type);
-
-        if (abs(gold - mine) > 1e-3)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "failed test: gold=%f, mine=%f, norm_type=%d, rows=%d, "
-                       "cols=%d, depth=%d, cn=%d\n", gold, mine, norm_type, rows, cols, depth, cn);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-        }
-    }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// reprojectImageTo3D
-class CV_GpuReprojectImageTo3DTest : public cvtest::BaseTest
-{
-public:
-    CV_GpuReprojectImageTo3DTest() {}
-
-protected:
-    void run(int)
-    {
-        Mat disp(320, 240, CV_8UC1);
-
-        RNG& rng = ts->get_rng();
-        rng.fill(disp, RNG::UNIFORM, Scalar(5), Scalar(30));
-
-        Mat Q(4, 4, CV_32FC1);
-        rng.fill(Q, RNG::UNIFORM, Scalar(0.1), Scalar(1));
-
-        Mat cpures;
-        GpuMat gpures;
-
-        reprojectImageTo3D(disp, cpures, Q, false);
-        reprojectImageTo3D(GpuMat(disp), gpures, Q);
-
-        Mat temp = gpures;
-
-        for (int y = 0; y < cpures.rows; ++y)
-        {
-            const Vec3f* cpu_row = cpures.ptr<Vec3f>(y);
-            const Vec4f* gpu_row = temp.ptr<Vec4f>(y);
-            for (int x = 0; x < cpures.cols; ++x)
-            {
-                Vec3f a = cpu_row[x];
-                Vec4f b = gpu_row[x];
-
-                if (fabs(a[0] - b[0]) > 1e-5 || fabs(a[1] - b[1]) > 1e-5 || fabs(a[2] - b[2]) > 1e-5)
-                {
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-            }
-        }
-    }
-};
-
-TEST(threshold, accuracy) { CV_GpuImageThresholdTest test; test.safe_run(); }
-TEST(resize, accuracy) { CV_GpuNppImageResizeTest test; test.safe_run(); }
-TEST(copyMakeBorder, accuracy) { CV_GpuNppImageCopyMakeBorderTest test; test.safe_run(); }
-TEST(warpAffine, accuracy) { CV_GpuNppImageWarpAffineTest test; test.safe_run(); }
-TEST(warpPerspective, accuracy) { CV_GpuNppImageWarpPerspectiveTest test; test.safe_run(); }
-TEST(integral, accuracy) { CV_GpuNppImageIntegralTest test; test.safe_run(); }
-TEST(cvtColor, accuracy) { CV_GpuCvtColorTest test; test.safe_run(); }
-TEST(histograms, accuracy) { CV_GpuHistogramsTest test; test.safe_run(); }
-TEST(cornerHearris, accuracy) { CV_GpuCornerHarrisTest test; test.safe_run(); }
-TEST(minEigen, accuracy) { CV_GpuCornerMinEigenValTest test; test.safe_run(); }
-TEST(columnSum, accuracy) { CV_GpuColumnSumTest test; test.safe_run(); }
-TEST(norm, accuracy) { CV_GpuNormTest test; test.safe_run(); }
-TEST(reprojectImageTo3D, accuracy) { CV_GpuReprojectImageTo3DTest test; test.safe_run(); }
-
-TEST(downsample, accuracy_on_8U)
-{
-    RNG& rng = cvtest::TS::ptr()->get_rng();
-    Size size(200 + cvtest::randInt(rng) % 1000, 200 + cvtest::randInt(rng) % 1000);
-    Mat src = cvtest::randomMat(rng, size, CV_8U, 0, 255, false);
-
-    for (int k = 2; k <= 5; ++k)
-    {
-        GpuMat d_dst;
-        downsample(GpuMat(src), d_dst, k);
-
-        Size dst_gold_size((src.cols + k - 1) / k, (src.rows + k - 1) / k);
-        ASSERT_EQ(dst_gold_size.width, d_dst.cols)
-            << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-        ASSERT_EQ(dst_gold_size.height, d_dst.rows)
-            << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-
-        Mat dst = d_dst;
-        for (int y = 0; y < dst.rows; ++y)
-            for (int x = 0; x < dst.cols; ++x)
-                ASSERT_EQ(src.at<uchar>(y * k, x * k), dst.at<uchar>(y, x))
-                    << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-    }
-}
-
-TEST(downsample, accuracy_on_32F)
-{
-    RNG& rng = cvtest::TS::ptr()->get_rng();
-    Size size(200 + cvtest::randInt(rng) % 1000, 200 + cvtest::randInt(rng) % 1000);
-    Mat src = cvtest::randomMat(rng, size, CV_32F, 0, 1, false);
-
-    for (int k = 2; k <= 5; ++k)
-    {
-        GpuMat d_dst;
-        downsample(GpuMat(src), d_dst, k);
-
-        Size dst_gold_size((src.cols + k - 1) / k, (src.rows + k - 1) / k);
-        ASSERT_EQ(dst_gold_size.width, d_dst.cols)
-            << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-        ASSERT_EQ(dst_gold_size.height, d_dst.rows)
-            << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-
-        Mat dst = d_dst;
-        for (int y = 0; y < dst.rows; ++y)
-            for (int x = 0; x < dst.cols; ++x)
-                ASSERT_FLOAT_EQ(src.at<float>(y * k, x * k), dst.at<float>(y, x))
-                    << "rows=" << size.height << ", cols=" << size.width << ", k=" << k;
-    }
-}
diff --git a/modules/gpu/test/test_main.cpp b/modules/gpu/test/test_main.cpp
index 89c1b272bc..05afdcdece 100644
--- a/modules/gpu/test/test_main.cpp
+++ b/modules/gpu/test/test_main.cpp
@@ -1,13 +1,137 @@
+/*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*/
+
 #include "test_precomp.hpp"
 
-int main(int argc, char **argv)
+#ifdef HAVE_CUDA
+#include <cuda_runtime_api.h>
+
+void print_info()
+{    
+    printf("\n");
+#if defined _WIN32
+#   if defined _WIN64
+        puts("OS: Windows 64");
+#   else
+        puts("OS: Windows 32");
+#   endif
+#elif defined linux
+#   if defined _LP64
+        puts("OS: Linux 64");
+#   else
+        puts("OS: Linux 32");
+#   endif
+#elif defined __APPLE__
+#   if defined _LP64
+        puts("OS: Apple 64");
+#   else
+        puts("OS: Apple 32");
+#   endif
+#endif
+
+    int deviceCount = cv::gpu::getCudaEnabledDeviceCount();
+    int driver;
+    cudaDriverGetVersion(&driver);
+
+    printf("CUDA Driver  version: %d\n", driver);        
+    printf("CUDA Runtime version: %d\n", CUDART_VERSION);    
+    printf("CUDA device count: %d\n\n", deviceCount);
+    
+
+    for (int i = 0; i < deviceCount; ++i)
+    {
+        cv::gpu::DeviceInfo info(i);
+        printf("Device %d:\n", i);
+        printf("    Name: %s\n", info.name().c_str());
+        printf("    Compute capability version: %d.%d\n", info.majorVersion(), info.minorVersion());
+        printf("    Total memory: %d Mb\n", static_cast<int>(static_cast<int>(info.totalMemory() / 1024.0) / 1024.0));
+        printf("    Free  memory: %d Mb\n", static_cast<int>(static_cast<int>(info.freeMemory() / 1024.0) / 1024.0));
+        if (info.isCompatible())
+            puts("    This device is compatible with current GPU module build\n");
+        else
+            puts("    This device is NOT compatible with current GPU module build\n");
+    }
+    
+    puts("GPU module was compiled for the following GPU archs:");
+    printf("    BIN: %s\n", CUDA_ARCH_BIN);
+    printf("    PTX: %s\n\n", CUDA_ARCH_PTX);
+}
+
+enum OutputLevel
+{
+    OutputLevelNone,
+    OutputLevelCompact,
+    OutputLevelFull
+};
+
+extern OutputLevel nvidiaTestOutputLevel;
+
+int main(int argc, char** argv)
 {
     cvtest::TS::ptr()->init("gpu");
-    ::testing::InitGoogleTest(&argc, argv);
-#ifdef HAVE_CUDA
+    testing::InitGoogleTest(&argc, argv);
+
+    const char* keys ="{ nvtest_output_level | nvtest_output_level | none | NVidia test verbosity level }";
+
+    cv::CommandLineParser parser(argc, (const char**)argv, keys);
+
+    std::string outputLevel = parser.get<std::string>("nvtest_output_level", "none");
+
+    if (outputLevel == "none")
+        nvidiaTestOutputLevel = OutputLevelNone;
+    else if (outputLevel == "compact")
+        nvidiaTestOutputLevel = OutputLevelCompact;
+    else if (outputLevel == "full")
+        nvidiaTestOutputLevel = OutputLevelFull;
+
+    print_info();
     return RUN_ALL_TESTS();
-#else
-    std::cerr << "opencv_test_gpu: OpenCV was compiled without GPU support\n";
-    return -1;
-#endif
-}
\ No newline at end of file
+}
+
+#else // HAVE_CUDA
+
+int main(int argc, char** argv)
+{
+    printf("OpenCV was built without CUDA support\n");
+    return 0;
+}
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_match_template.cpp b/modules/gpu/test/test_match_template.cpp
deleted file mode 100644
index b646723051..0000000000
--- a/modules/gpu/test/test_match_template.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-/*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 GpuMaterials 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 bpied warranties, including, but not limited to, the bpied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "test_precomp.hpp"
-#include <string>
-#include <iostream>
-
-//#define SHOW_TIME
-
-#ifdef SHOW_TIME
-#include <ctime>
-#define F(x) x
-#else
-#define F(x)
-#endif
-
-using namespace cv;
-using namespace std;
-
-struct CV_GpuMatchTemplateTest: cvtest::BaseTest 
-{
-    CV_GpuMatchTemplateTest() {}
-
-    void run(int)
-    {
-        bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) &&
-                         gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-        if (!double_ok)
-        {
-            // For sqrIntegral
-            ts->printf(cvtest::TS::CONSOLE, "\nCode and device double support is required (CC >= 1.3)");
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        Mat image, templ;
-        Mat dst_gold;
-        gpu::GpuMat dst;
-        int n, m, h, w;
-        F(clock_t t;)
-
-        RNG& rng = ts->get_rng();
-
-        for (int cn = 1; cn <= 4; ++cn)
-        {
-            F(ts->printf(cvtest::TS::CONSOLE, "cn: %d\n", cn);)
-            for (int i = 0; i <= 0; ++i)
-            {
-                n = rng.uniform(30, 100);
-                m = rng.uniform(30, 100);
-                h = rng.uniform(5, n - 1);
-                w = rng.uniform(5, m - 1);
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_SQDIFF);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_SQDIFF);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), 5 * h * w * 1e-4f, "SQDIFF 8U")) return;
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_SQDIFF_NORMED);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_SQDIFF_NORMED);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), h * w * 1e-5f, "SQDIFF_NOREMD 8U")) return;
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_CCORR);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_CCORR);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), 5 * h * w * cn * cn * 1e-5f, "CCORR 8U")) return;
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_CCORR_NORMED);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_CCORR_NORMED);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), h * w * 1e-6f, "CCORR_NORMED 8U")) return;
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_CCOEFF);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_CCOEFF);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), 5 * h * w * cn * cn * 1e-5f, "CCOEFF 8U")) return;
-
-                gen(image, n, m, CV_8U, cn);
-                gen(templ, h, w, CV_8U, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_CCOEFF_NORMED);
-                F(cout << "depth: 8U cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_CCOEFF_NORMED);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), h * w * 1e-6f, "CCOEFF_NORMED 8U")) return;
-
-                gen(image, n, m, CV_32F, cn);
-                gen(templ, h, w, CV_32F, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_SQDIFF);
-                F(cout << "depth: 32F cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_SQDIFF);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), 0.25f * h * w * 1e-5f, "SQDIFF 32F")) return;
-
-                gen(image, n, m, CV_32F, cn);
-                gen(templ, h, w, CV_32F, cn);
-                F(t = clock();)
-                matchTemplate(image, templ, dst_gold, CV_TM_CCORR);
-                F(cout << "depth: 32F cn: " << cn << " n: " << n << " m: " << m << " w: " << w << " h: " << h << endl;)
-                F(cout << "cpu:" << clock() - t << endl;)
-                F(t = clock();)
-                gpu::matchTemplate(gpu::GpuMat(image), gpu::GpuMat(templ), dst, CV_TM_CCORR);
-                F(cout << "gpu_block: " << clock() - t << endl;)
-                if (!check(dst_gold, Mat(dst), 0.25f * h * w * 1e-5f, "CCORR 32F")) return;
-            }
-        }
-    }
-
-    void gen(Mat& a, int rows, int cols, int depth, int cn)
-    {
-        RNG rng;
-        a.create(rows, cols, CV_MAKETYPE(depth, cn));
-        if (depth == CV_8U)
-            rng.fill(a, RNG::UNIFORM, Scalar::all(1), Scalar::all(10));
-        else if (depth == CV_32F)
-            rng.fill(a, RNG::UNIFORM, Scalar::all(0.001f), Scalar::all(1.f));
-    }
-
-    bool check(const Mat& a, const Mat& b, float max_err, const string& method="")
-    {
-        if (a.size() != b.size())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad size, method=%s\n", method.c_str());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-
-        //for (int i = 0; i < a.rows; ++i)
-        //{
-        //    for (int j = 0; j < a.cols; ++j)
-        //    {
-        //        float a_ = a.at<float>(i, j);
-        //        float b_ = b.at<float>(i, j);
-        //        if (fabs(a_ - b_) > max_err)
-        //        {
-        //            ts->printf(cvtest::TS::CONSOLE, "a=%f, b=%f, i=%d, j=%d\n", a_, b_, i, j);
-        //            cin.get();
-        //        }
-        //    }
-        //}
-
-        float err = (float)norm(a, b, NORM_INF);
-        if (err > max_err)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad accuracy: %f, method=%s\n", err, method.c_str());
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return false;
-        }
-
-        return true;
-    }
-};
-
-TEST(matchTemplate, accuracy) { CV_GpuMatchTemplateTest test; test.safe_run(); }
-
-struct CV_GpuMatchTemplateFindPatternInBlackTest: cvtest::BaseTest 
-{
-    CV_GpuMatchTemplateFindPatternInBlackTest() {}
-
-    void run(int)
-    {
-        bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) &&
-                         gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-        if (!double_ok)
-        {
-            // For sqrIntegral
-            ts->printf(cvtest::TS::CONSOLE, "\nCode and device double support is required (CC >= 1.3)");
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        Mat image = imread(std::string(ts->get_data_path()) + "matchtemplate/black.png");
-        if (image.empty())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "can't open file '%s'", (std::string(ts->get_data_path())
-                                                               + "matchtemplate/black.png").c_str());
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        Mat pattern = imread(std::string(ts->get_data_path()) + "matchtemplate/cat.png");
-        if (pattern.empty())
-        {
-            ts->printf(cvtest::TS::CONSOLE, "can't open file '%s'", (std::string(ts->get_data_path())
-                                                               + "matchtemplate/cat.png").c_str());
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        gpu::GpuMat d_image(image);
-        gpu::GpuMat d_pattern(pattern);
-        gpu::GpuMat d_result;
-
-        double maxValue;
-        Point maxLoc;
-        Point maxLocGold(284, 12);
-
-        gpu::matchTemplate(d_image, d_pattern, d_result, CV_TM_CCOEFF_NORMED);
-        gpu::minMaxLoc(d_result, NULL, &maxValue, NULL, &maxLoc );
-        if (maxLoc != maxLocGold)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad match (CV_TM_CCOEFF_NORMED): %d %d, must be at: %d %d",
-                       maxLoc.x, maxLoc.y, maxLocGold.x, maxLocGold.y);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return;
-        }
-
-        gpu::matchTemplate(d_image, d_pattern, d_result, CV_TM_CCORR_NORMED);
-        gpu::minMaxLoc(d_result, NULL, &maxValue, NULL, &maxLoc );
-        if (maxLoc != maxLocGold)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "bad match (CV_TM_CCORR_NORMED): %d %d, must be at: %d %d",
-                       maxLoc.x, maxLoc.y, maxLocGold.x, maxLocGold.y);
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return;
-        }
-    }
-};
-
-TEST(matchTemplate, find_pattern_in_black) { CV_GpuMatchTemplateFindPatternInBlackTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_matop.cpp b/modules/gpu/test/test_matop.cpp
new file mode 100644
index 0000000000..800fc88c7e
--- /dev/null
+++ b/modules/gpu/test/test_matop.cpp
@@ -0,0 +1,616 @@
+/*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 GpuMaterials 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 bpied warranties, including, but not limited to, the bpied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+////////////////////////////////////////////////////////////////////////////////
+// merge
+
+struct Merge : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    std::vector<cv::Mat> src;
+
+    cv::Mat dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        int depth = CV_MAT_DEPTH(type);
+        int num_channels = CV_MAT_CN(type);
+        src.reserve(num_channels);
+        for (int i = 0; i < num_channels; ++i)
+            src.push_back(cv::Mat(size, depth, cv::Scalar::all(i))); 
+
+        cv::merge(src, dst_gold);
+    }
+};
+
+TEST_P(Merge, Accuracy)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        std::vector<cv::gpu::GpuMat> dev_src;
+        cv::gpu::GpuMat dev_dst;
+
+        for (size_t i = 0; i < src.size(); ++i)
+            dev_src.push_back(cv::gpu::GpuMat(src[i]));
+
+        cv::gpu::merge(dev_src, dev_dst); 
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, Merge, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(all_types())));
+
+////////////////////////////////////////////////////////////////////////////////
+// split
+
+struct Split : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat src;
+
+    std::vector<cv::Mat> dst_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src.create(size, type);
+        src.setTo(cv::Scalar(1.0, 2.0, 3.0, 4.0));
+        cv::split(src, dst_gold);
+    }
+};
+
+TEST_P(Split, Accuracy)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    std::vector<cv::Mat> dst;
+    
+    ASSERT_NO_THROW(
+        std::vector<cv::gpu::GpuMat> dev_dst;
+        cv::gpu::split(cv::gpu::GpuMat(src), dev_dst);
+
+        dst.resize(dev_dst.size());
+        for (size_t i = 0; i < dev_dst.size(); ++i)
+            dev_dst[i].download(dst[i]);
+    );
+
+    ASSERT_EQ(dst_gold.size(), dst.size());
+
+    for (size_t i = 0; i < dst_gold.size(); ++i)
+    {
+        EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, Split, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(all_types())));
+
+////////////////////////////////////////////////////////////////////////////////
+// split_merge_consistency
+
+struct SplitMerge : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat orig;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        orig.create(size, type);
+        orig.setTo(cv::Scalar(1.0, 2.0, 3.0, 4.0));
+    }
+};
+
+TEST_P(SplitMerge, Consistency)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat final;
+
+    ASSERT_NO_THROW(
+        std::vector<cv::gpu::GpuMat> dev_vec;
+        cv::gpu::GpuMat dev_final;
+
+        cv::gpu::split(cv::gpu::GpuMat(orig), dev_vec);    
+        cv::gpu::merge(dev_vec, dev_final);
+
+        dev_final.download(final);
+    );
+
+    EXPECT_MAT_NEAR(orig, final, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, SplitMerge, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(all_types())));
+
+////////////////////////////////////////////////////////////////////////////////
+// setTo
+
+struct SetTo : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat mat_gold;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        mat_gold.create(size, type);
+    }
+};
+
+TEST_P(SetTo, Zero)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    static cv::Scalar zero = cv::Scalar::all(0);
+
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_mat(mat_gold);
+
+        mat_gold.setTo(zero);
+        dev_mat.setTo(zero);
+
+        dev_mat.download(mat);
+    );
+
+    EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+}
+
+TEST_P(SetTo, SameVal)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    static cv::Scalar s = cv::Scalar::all(1);
+
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_mat(mat_gold);
+
+        mat_gold.setTo(s);
+        dev_mat.setTo(s);
+
+        dev_mat.download(mat);
+    );
+
+    EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+}
+
+TEST_P(SetTo, DifferentVal)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    static cv::Scalar s = cv::Scalar(1, 2, 3, 4);
+
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_mat(mat_gold);
+
+        mat_gold.setTo(s);
+        dev_mat.setTo(s);
+
+        dev_mat.download(mat);
+    );
+
+    EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+}
+
+TEST_P(SetTo, Masked)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    static cv::Scalar s = cv::Scalar(1, 2, 3, 4);
+
+    
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+    cv::Mat mask = cvtest::randomMat(rng, mat_gold.size(), CV_8UC1, 0.0, 1.5, false);
+
+    cv::Mat mat;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_mat(mat_gold);
+
+        mat_gold.setTo(s, mask);
+        dev_mat.setTo(s, cv::gpu::GpuMat(mask));
+
+        dev_mat.download(mat);
+    );
+
+    EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, SetTo, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(all_types())));
+
+////////////////////////////////////////////////////////////////////////////////
+// copyTo
+
+struct CopyTo : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int type;
+
+    cv::Size size;
+    cv::Mat src;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        type = std::tr1::get<1>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, type, 0.0, 127.0, false);
+    }
+};
+
+TEST_P(CopyTo, WithoutMask)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::Mat dst_gold;
+    src.copyTo(dst_gold);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_src(src);
+
+        cv::gpu::GpuMat dev_dst;
+
+        dev_src.copyTo(dev_dst);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(CopyTo, Masked)
+{
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(type);
+    PRINT_PARAM(size);
+
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    cv::Mat mask = cvtest::randomMat(rng, src.size(), CV_8UC1, 0.0, 2.0, false);
+
+    cv::Mat dst_gold(src.size(), src.type(), cv::Scalar::all(0));
+    src.copyTo(dst_gold, mask);
+
+    cv::Mat dst;
+
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_src(src);
+
+        cv::gpu::GpuMat dev_dst(src.size(), src.type(), cv::Scalar::all(0));
+
+        dev_src.copyTo(dev_dst, cv::gpu::GpuMat(mask));
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, CopyTo, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(all_types())));
+
+////////////////////////////////////////////////////////////////////////////////
+// convertTo
+
+struct ConvertTo : testing::TestWithParam< std::tr1::tuple<cv::gpu::DeviceInfo, int, int> >
+{
+    cv::gpu::DeviceInfo devInfo;
+    int depth1;
+    int depth2;
+
+    cv::Size size;
+    cv::Mat src;
+
+    virtual void SetUp() 
+    {
+        devInfo = std::tr1::get<0>(GetParam());
+        depth1 = std::tr1::get<1>(GetParam());
+        depth2 = std::tr1::get<2>(GetParam());
+
+        cv::gpu::setDevice(devInfo.deviceID());
+        
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        size = cv::Size(rng.uniform(20, 150), rng.uniform(20, 150));
+
+        src = cvtest::randomMat(rng, size, depth1, 0.0, 127.0, false);
+    }
+};
+
+TEST_P(ConvertTo, WithoutScaling)
+{
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(depth1);
+    PRINT_TYPE(depth2);
+    PRINT_PARAM(size);
+
+    cv::Mat dst_gold;
+    src.convertTo(dst_gold, depth2);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_src(src);
+
+        cv::gpu::GpuMat dev_dst;
+
+        dev_src.convertTo(dev_dst, depth2);
+
+        dev_dst.download(dst);
+    );
+
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+}
+
+TEST_P(ConvertTo, WithScaling)
+{
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        return;
+
+    PRINT_PARAM(devInfo);
+    PRINT_TYPE(depth1);
+    PRINT_TYPE(depth2);
+    PRINT_PARAM(size);
+    
+    cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+    const double a = rng.uniform(0.0, 1.0);
+    const double b = rng.uniform(-10.0, 10.0);
+    
+    PRINT_PARAM(a);
+    PRINT_PARAM(b);
+
+    cv::Mat dst_gold;
+    src.convertTo(dst_gold, depth2, a, b);
+
+    cv::Mat dst;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::GpuMat dev_src(src);
+
+        cv::gpu::GpuMat dev_dst;
+
+        dev_src.convertTo(dev_dst, depth2, a, b);
+
+        dev_dst.download(dst);
+    );
+
+    const double eps = depth2 < CV_32F ? 1 : 1e-4;
+
+    EXPECT_MAT_NEAR(dst_gold, dst, eps);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, ConvertTo, testing::Combine(
+                        testing::ValuesIn(devices()), 
+                        testing::ValuesIn(types(CV_8U, CV_64F, 1, 1)), 
+                        testing::ValuesIn(types(CV_8U, CV_64F, 1, 1))));
+
+////////////////////////////////////////////////////////////////////////////////
+// async
+
+struct Async : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    cv::gpu::CudaMem src;
+
+    cv::Mat dst_gold0;
+    cv::Mat dst_gold1;
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        cv::RNG& rng = cvtest::TS::ptr()->get_rng();
+
+        int rows = rng.uniform(100, 200);
+        int cols = rng.uniform(100, 200);
+
+        src = cv::gpu::CudaMem(cv::Mat::zeros(rows, cols, CV_8UC1));        
+
+        dst_gold0 = cv::Mat(rows, cols, CV_8UC1, cv::Scalar::all(255));
+        dst_gold1 = cv::Mat(rows, cols, CV_8UC1, cv::Scalar::all(128));
+    }
+};
+
+TEST_P(Async, Accuracy)
+{
+    PRINT_PARAM(devInfo);
+
+    cv::Mat dst0, dst1;
+    
+    ASSERT_NO_THROW(
+        cv::gpu::CudaMem cpudst0;
+        cv::gpu::CudaMem cpudst1;
+
+        cv::gpu::GpuMat gpusrc;
+        cv::gpu::GpuMat gpudst0;
+        cv::gpu::GpuMat gpudst1(src.rows, src.cols, CV_8UC1);
+
+        cv::gpu::Stream stream0;
+        cv::gpu::Stream stream1;
+
+        stream0.enqueueUpload(src, gpusrc);
+        cv::gpu::bitwise_not(gpusrc, gpudst0, cv::gpu::GpuMat(), stream0);
+        stream0.enqueueDownload(gpudst0, cpudst0);
+
+        stream1.enqueueMemSet(gpudst1, cv::Scalar::all(128));
+        stream1.enqueueDownload(gpudst1, cpudst1);
+
+        stream0.waitForCompletion();
+        stream1.waitForCompletion();
+
+        dst0 = cpudst0.createMatHeader();
+        dst1 = cpudst1.createMatHeader();
+    );
+
+    EXPECT_MAT_NEAR(dst_gold0, dst0, 0.0);
+    EXPECT_MAT_NEAR(dst_gold1, dst1, 0.0);
+}
+
+INSTANTIATE_TEST_CASE_P(MatOp, Async, testing::ValuesIn(devices()));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_meanshift.cpp b/modules/gpu/test/test_meanshift.cpp
deleted file mode 100644
index b297b982ac..0000000000
--- a/modules/gpu/test/test_meanshift.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-#include <iostream>
-#include <string>
-
-using namespace cv;
-using namespace cv::gpu;
-
-
-struct CV_GpuMeanShiftTest : public cvtest::BaseTest
-{
-    CV_GpuMeanShiftTest() {}
-
-    void run(int)
-    {
-        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
-        if (!cc12_ok)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        int spatialRad = 30;
-        int colorRad = 30;
-
-        cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png");
-        cv::Mat img_template;       
-        
-        if (cv::gpu::TargetArchs::builtWith(cv::gpu::FEATURE_SET_COMPUTE_20) &&
-            cv::gpu::DeviceInfo().supports(cv::gpu::FEATURE_SET_COMPUTE_20))
-            img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result.png");
-        else
-            img_template = cv::imread(std::string(ts->get_data_path()) + "meanshift/con_result_CC1X.png");
-
-        if (img.empty() || img_template.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        cv::Mat rgba;
-        cvtColor(img, rgba, CV_BGR2BGRA);
-
-
-        cv::gpu::GpuMat res;
-        cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), res, spatialRad, colorRad );
-
-        if (res.type() != CV_8UC4)
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return;
-        }
-
-        cv::Mat result;
-        res.download(result);
-
-        uchar maxDiff = 0;
-        for (int j = 0; j < result.rows; ++j)
-        {
-            const uchar* res_line = result.ptr<uchar>(j);
-            const uchar* ref_line = img_template.ptr<uchar>(j);
-
-            for (int i = 0; i < result.cols; ++i)
-            {
-                for (int k = 0; k < 3; ++k)
-                {
-                    const uchar& ch1 = res_line[result.channels()*i + k];
-                    const uchar& ch2 = ref_line[img_template.channels()*i + k];
-                    uchar diff = static_cast<uchar>(abs(ch1 - ch2));
-                    if (maxDiff < diff)
-                        maxDiff = diff;
-                }
-            }
-        }
-        if (maxDiff > 0)
-        {
-            ts->printf(cvtest::TS::LOG, "\nMeanShift maxDiff = %d\n", maxDiff);
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-
-};
-
-TEST(meanShift, accuracy) { CV_GpuMeanShiftTest test; test.safe_run(); }
-
-struct CV_GpuMeanShiftProcTest : public cvtest::BaseTest
-{
-    CV_GpuMeanShiftProcTest() {}
-
-    void run(int)
-    {
-        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
-        if (!cc12_ok)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        int spatialRad = 30;
-        int colorRad = 30;
-
-        cv::Mat img = cv::imread(std::string(ts->get_data_path()) + "meanshift/cones.png");
-
-        if (img.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        cv::Mat rgba;
-        cvtColor(img, rgba, CV_BGR2BGRA);
-
-        cv::gpu::GpuMat h_rmap_filtered;
-        cv::gpu::meanShiftFiltering( cv::gpu::GpuMat(rgba), h_rmap_filtered, spatialRad, colorRad );
-
-        cv::gpu::GpuMat d_rmap;
-        cv::gpu::GpuMat d_spmap;
-        cv::gpu::meanShiftProc( cv::gpu::GpuMat(rgba), d_rmap, d_spmap, spatialRad, colorRad );
-
-        if (d_rmap.type() != CV_8UC4)
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            return;
-        }
-
-        cv::Mat rmap_filtered;
-        h_rmap_filtered.download(rmap_filtered);
-
-        cv::Mat rmap;
-        d_rmap.download(rmap);
-
-        uchar maxDiff = 0;
-        for (int j = 0; j < rmap_filtered.rows; ++j)
-        {
-            const uchar* res_line = rmap_filtered.ptr<uchar>(j);
-            const uchar* ref_line = rmap.ptr<uchar>(j);
-
-            for (int i = 0; i < rmap_filtered.cols; ++i)
-            {
-                for (int k = 0; k < 3; ++k)
-                {
-                    const uchar& ch1 = res_line[rmap_filtered.channels()*i + k];
-                    const uchar& ch2 = ref_line[rmap.channels()*i + k];
-                    uchar diff = static_cast<uchar>(abs(ch1 - ch2));
-                    if (maxDiff < diff)
-                        maxDiff = diff;
-                }
-            }
-        }
-        if (maxDiff > 0)
-        {
-            ts->printf(cvtest::TS::LOG, "\nMeanShiftProc maxDiff = %d\n", maxDiff);
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        cv::Mat spmap;
-        d_spmap.download(spmap);
-
-        cv::Mat spmap_template;
-        cv::FileStorage fs;
-
-        if (cv::gpu::TargetArchs::builtWith(cv::gpu::FEATURE_SET_COMPUTE_20) &&
-            cv::gpu::DeviceInfo().supports(cv::gpu::FEATURE_SET_COMPUTE_20))
-            fs.open(std::string(ts->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
-        else
-            fs.open(std::string(ts->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
-        fs["spmap"] >> spmap_template;
-
-        for (int y = 0; y < spmap.rows; ++y) {
-            for (int x = 0; x < spmap.cols; ++x) {
-                cv::Point_<short> expected = spmap_template.at<cv::Point_<short> >(y, x);
-                cv::Point_<short> actual = spmap.at<cv::Point_<short> >(y, x);
-                int diff = (expected - actual).dot(expected - actual);
-                if (actual != expected) {
-                    ts->printf(cvtest::TS::LOG, "\nMeanShiftProc SpMap is bad, diff=%d\n", diff);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-                    return;
-                }
-            }
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-
-};
-
-TEST(meanShiftProc, accuracy) { CV_GpuMeanShiftProcTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_mssegmentation.cpp b/modules/gpu/test/test_mssegmentation.cpp
deleted file mode 100644
index b64914704b..0000000000
--- a/modules/gpu/test/test_mssegmentation.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*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*/
-
-#include <iostream>
-#include <string>
-#include <iosfwd>
-#include "test_precomp.hpp"
-using namespace cv;
-using namespace cv::gpu;
-using namespace std;
-
-struct CV_GpuMeanShiftSegmentationTest : public cvtest::BaseTest {
-    CV_GpuMeanShiftSegmentationTest() {}
-
-    void run(int) 
-    {
-        bool cc12_ok = TargetArchs::builtWith(FEATURE_SET_COMPUTE_12) && DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
-        if (!cc12_ok)
-        {
-            ts->printf(cvtest::TS::CONSOLE, "\nCompute capability 1.2 is required");
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        Mat img_rgb = imread(string(ts->get_data_path()) + "meanshift/cones.png");
-        if (img_rgb.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        Mat img;
-        cvtColor(img_rgb, img, CV_BGR2BGRA);
-
-
-        for (int minsize = 0; minsize < 2000; minsize = (minsize + 1) * 4)
-        {
-            stringstream path;
-            path << ts->get_data_path() << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
-            if (TargetArchs::builtWith(FEATURE_SET_COMPUTE_20) && DeviceInfo().supports(FEATURE_SET_COMPUTE_20))
-                path << ".png";
-            else
-                path << "_CC1X.png";
-
-            Mat dst;
-            meanShiftSegmentation((GpuMat)img, dst, 10, 10, minsize);
-            Mat dst_rgb;
-            cvtColor(dst, dst_rgb, CV_BGRA2BGR);
-
-            //imwrite(path.str(), dst_rgb);
-            Mat dst_ref = imread(path.str());
-            if (dst_ref.empty())
-            {
-                ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-                return;
-            }
-            if (CheckSimilarity(dst_rgb, dst_ref, 1e-3f) != cvtest::TS::OK)
-            {
-                ts->printf(cvtest::TS::LOG, "\ndiffers from image *minsize%d.png\n", minsize);
-                ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
-            }
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }    
-
-    int CheckSimilarity(const Mat& m1, const Mat& m2, float max_err)
-    {
-        Mat diff;
-        cv::matchTemplate(m1, m2, diff, CV_TM_CCORR_NORMED);
-
-        float err = abs(diff.at<float>(0, 0) - 1.f);
-
-        if (err > max_err)
-            return cvtest::TS::FAIL_INVALID_OUTPUT;
-
-        return cvtest::TS::OK;
-    }
-
-
-};
-
-
-TEST(meanShiftSegmentation, regression) { CV_GpuMeanShiftSegmentationTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp
index 412e5fcaa8..2620dd7f48 100644
--- a/modules/gpu/test/test_nvidia.cpp
+++ b/modules/gpu/test/test_nvidia.cpp
@@ -40,35 +40,198 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "cvconfig.h"
 
-class CV_NVidiaTestsCaller : public cvtest::BaseTest
+#ifdef HAVE_CUDA
+
+enum OutputLevel
 {
-public:
-    CV_NVidiaTestsCaller() {}
-    virtual ~CV_NVidiaTestsCaller() {}
-
-protected:
-    
-	void run( int )
-	{   
-		;
-
-#if defined(HAVE_CUDA)
-		bool main_nvidia(const std::string&);
-
-		// Invoke all NVIDIA Staging tests and obtain the result
-		bool passed = main_nvidia(std::string(ts->get_data_path()) + "haarcascade/");
-
-		if (passed)
-		    ts->set_failed_test_info(cvtest::TS::OK);
-		else
-		    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-
-#else
-		ts->set_failed_test_info(cvtest::TS::SKIPPED);
-#endif
-	}   
+    OutputLevelNone,
+    OutputLevelCompact,
+    OutputLevelFull
 };
 
-TEST(NVidia, multitest) { CV_NVidiaTestsCaller test; test.safe_run(); }
+bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_RectStdDev(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Resize(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NPPST_Transpose(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Vector_Operations(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Haar_Cascade_Loader(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Haar_Cascade_Application(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Hypotheses_Filtration(const std::string& test_data_path, OutputLevel outputLevel);
+bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel outputLevel);
+
+struct NVidiaTest : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    static std::string path;
+
+    cv::gpu::DeviceInfo devInfo;
+
+    static void SetUpTestCase() 
+    {
+        path = std::string(cvtest::TS::ptr()->get_data_path()) + "haarcascade/";
+    }
+
+    virtual void SetUp() 
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+std::string NVidiaTest::path;
+
+struct NPPST : NVidiaTest {};
+struct NCV : NVidiaTest {};
+
+OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
+
+TEST_P(NPPST, Integral) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, SquaredIntegral) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Squared_Integral_Image(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, RectStdDev) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_RectStdDev(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, Resize) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Resize(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, VectorOperations) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Vector_Operations(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NPPST, Transpose) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NPPST_Transpose(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, VectorOperations) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Vector_Operations(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HaarCascadeLoader) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Haar_Cascade_Loader(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HaarCascadeApplication) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Haar_Cascade_Application(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, HypothesesFiltration) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Hypotheses_Filtration(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+TEST_P(NCV, Visualization) 
+{
+    PRINT_PARAM(devInfo);
+
+    bool res;
+
+    ASSERT_NO_THROW(
+        res = nvidia_NCV_Visualization(path, nvidiaTestOutputLevel);
+    );
+
+    ASSERT_TRUE(res);
+}
+
+INSTANTIATE_TEST_CASE_P(NVidia, NPPST, testing::ValuesIn(devices()));
+INSTANTIATE_TEST_CASE_P(NVidia, NCV, testing::ValuesIn(devices()));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_operator_convert_to.cpp b/modules/gpu/test/test_operator_convert_to.cpp
deleted file mode 100644
index c5c55b3d95..0000000000
--- a/modules/gpu/test/test_operator_convert_to.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-#include <fstream>
-#include <iterator>
-#include <numeric>
-
-using namespace cv;
-using namespace std;
-using namespace gpu;
-
-class CV_GpuMatOpConvertToTest : public cvtest::BaseTest
-{
-    public:
-        CV_GpuMatOpConvertToTest() {}
-        ~CV_GpuMatOpConvertToTest() {}
-
-    protected:
-        void run(int);
-};
-
-void CV_GpuMatOpConvertToTest::run(int /* start_from */)
-{
-    const Size img_size(67, 35);
-
-    const char* types_str[] = {"CV_8U", "CV_8S", "CV_16U", "CV_16S", "CV_32S", "CV_32F", "CV_64F"};
-
-    bool passed = true;
-    int lastType = CV_32F;
-
-    if (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE))
-        lastType = CV_64F;
-
-    for (int i = 0; i <= lastType && passed; ++i)
-    {
-        for (int j = 0; j <= lastType && passed; ++j)
-        {
-            for (int c = 1; c < 5 && passed; ++c)
-            {
-                const int src_type = CV_MAKETYPE(i, c);
-                const int dst_type = j;
-
-                cv::RNG& rng = ts->get_rng();
-
-                Mat cpumatsrc(img_size, src_type);
-                rng.fill(cpumatsrc, RNG::UNIFORM, Scalar::all(0), Scalar::all(300));
-
-                GpuMat gpumatsrc(cpumatsrc);
-                Mat cpumatdst;
-                GpuMat gpumatdst;
-
-                cpumatsrc.convertTo(cpumatdst, dst_type, 0.5, 3.0);
-                gpumatsrc.convertTo(gpumatdst, dst_type, 0.5, 3.0);
-
-                double r = norm(cpumatdst, (Mat)gpumatdst, NORM_INF);
-                if (r > 1)
-                {
-                    ts->printf(cvtest::TS::LOG,
-                               "\nFAILED: SRC_TYPE=%sC%d DST_TYPE=%s NORM = %f\n",
-                               types_str[i], c, types_str[j], r);
-                    passed = false;
-                }
-            }
-        }
-    }
-
-    ts->set_failed_test_info(passed ? cvtest::TS::OK : cvtest::TS::FAIL_GENERIC);
-}
-
-TEST(GpuMat_convertTo, accuracy) { CV_GpuMatOpConvertToTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_operator_copy_to.cpp b/modules/gpu/test/test_operator_copy_to.cpp
deleted file mode 100644
index dc1e2280bd..0000000000
--- a/modules/gpu/test/test_operator_copy_to.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-#include <fstream>
-#include <iterator>
-#include <numeric>
-#include <iomanip> // for  cout << setw()
-
-using namespace cv;
-using namespace std;
-using namespace gpu;
-
-class CV_GpuMatOpCopyToTest : public cvtest::BaseTest
-{
-    public:
-        CV_GpuMatOpCopyToTest()
-        {
-            rows = 234;
-            cols = 123;
-        }
-        ~CV_GpuMatOpCopyToTest() {}
-
-    protected:
-        void run(int);
-        template <typename T>
-        void print_mat(const T & mat, const std::string & name) const;
-        bool compare_matrix(cv::Mat & cpumat, gpu::GpuMat & gpumat);
-
-    private:
-        int rows;
-        int cols;
-};
-
-template<typename T>
-void CV_GpuMatOpCopyToTest::print_mat(const T & mat, const std::string & name) const { cv::imshow(name, mat); }
-
-bool CV_GpuMatOpCopyToTest::compare_matrix(cv::Mat & cpumat, gpu::GpuMat & gpumat)
-{
-    Mat cmat(cpumat.size(), cpumat.type(), Scalar::all(0));
-    GpuMat gmat(cmat);
-
-    Mat cpumask(cpumat.size(), CV_8U);
-
-    cv::RNG& rng = ts->get_rng();
-
-    rng.fill(cpumask, RNG::NORMAL, Scalar::all(0), Scalar::all(127));
-
-    threshold(cpumask, cpumask, 0, 127, THRESH_BINARY);
-
-    GpuMat gpumask(cpumask);
-
-    //int64 time = getTickCount();
-    cpumat.copyTo(cmat, cpumask);
-    //int64 time1 = getTickCount();
-    gpumat.copyTo(gmat, gpumask);
-    //int64 time2 = getTickCount();
-
-    //std::cout << "\ntime cpu: " << std::fixed << std::setprecision(12) << 1.0 / double((time1 - time)  / (double)getTickFrequency());
-    //std::cout << "\ntime gpu: " << std::fixed << std::setprecision(12) << 1.0 / double((time2 - time1) / (double)getTickFrequency());
-    //std::cout << "\n";
-
-#ifdef PRINT_MATRIX
-    print_mat(cmat, "cpu mat");
-    print_mat(gmat, "gpu mat");
-    print_mat(cpumask, "cpu mask");
-    print_mat(gpumask, "gpu mask");
-    cv::waitKey(0);
-#endif
-
-    double ret = norm(cmat, (Mat)gmat);
-
-    if (ret < 1.0)
-        return true;
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "\nNorm: %f\n", ret);
-        return false;
-    }
-}
-
-void CV_GpuMatOpCopyToTest::run( int /* start_from */)
-{
-    bool is_test_good = true;
-
-    int lastType = CV_32F;
-
-    if (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE))
-        lastType = CV_64F;
-
-    for (int i = 0 ; i <= lastType; i++)
-    {
-        Mat cpumat(rows, cols, i);
-        cpumat.setTo(Scalar::all(127));
-
-        GpuMat gpumat(cpumat);
-
-        is_test_good &= compare_matrix(cpumat, gpumat);
-    }
-
-    if (is_test_good == true)
-        ts->set_failed_test_info(cvtest::TS::OK);
-    else
-        ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-}
-
-TEST(GpuMat_copyTo, accuracy) { CV_GpuMatOpCopyToTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_operator_set_to.cpp b/modules/gpu/test/test_operator_set_to.cpp
deleted file mode 100644
index f09f411714..0000000000
--- a/modules/gpu/test/test_operator_set_to.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace std;
-using namespace gpu;
-
-class CV_GpuMatOpSetToTest : public cvtest::BaseTest
-{
-public:
-    CV_GpuMatOpSetToTest();
-    ~CV_GpuMatOpSetToTest() {}
-
-protected:
-    void run(int);
-
-    bool testSetTo(cv::Mat& cpumat, gpu::GpuMat& gpumat, const cv::Mat& cpumask = cv::Mat(), const cv::gpu::GpuMat& gpumask = cv::gpu::GpuMat());
-
-private:
-    int rows;
-    int cols;
-    Scalar s;
-};
-
-CV_GpuMatOpSetToTest::CV_GpuMatOpSetToTest()
-{
-    rows = 35;
-    cols = 67;
-
-    s.val[0] = 127.0;
-    s.val[1] = 127.0;
-    s.val[2] = 127.0;
-    s.val[3] = 127.0;
-}
-
-bool CV_GpuMatOpSetToTest::testSetTo(cv::Mat& cpumat, gpu::GpuMat& gpumat, const cv::Mat& cpumask, const cv::gpu::GpuMat& gpumask)
-{
-    cpumat.setTo(s, cpumask);
-    gpumat.setTo(s, gpumask);
-
-    double ret = norm(cpumat, (Mat)gpumat, NORM_INF);
-
-    if (ret < std::numeric_limits<double>::epsilon())
-        return true;
-    else
-    {
-        ts->printf(cvtest::TS::LOG, "\nNorm: %f\n", ret);
-        return false;
-    }
-}
-
-void CV_GpuMatOpSetToTest::run( int /* start_from */)
-{
-    bool is_test_good = true;
-
-    cv::Mat cpumask(rows, cols, CV_8UC1);
-    cv::RNG& rng = ts->get_rng();
-    rng.fill(cpumask, RNG::UNIFORM, cv::Scalar::all(0.0), cv::Scalar(1.5));
-    cv::gpu::GpuMat gpumask(cpumask);
-
-    int lastType = CV_32F;
-
-    if (TargetArchs::builtWith(NATIVE_DOUBLE) && DeviceInfo().supports(NATIVE_DOUBLE))
-        lastType = CV_64F;
-
-    for (int i = 0; i <= lastType; i++)
-    {
-        for (int cn = 1; cn <= 4; ++cn)
-        {
-            int mat_type = CV_MAKETYPE(i, cn);
-            Mat cpumat(rows, cols, mat_type, Scalar::all(0));
-            GpuMat gpumat(cpumat);
-            is_test_good &= testSetTo(cpumat, gpumat, cpumask, gpumask);
-        }
-    }
-
-    if (is_test_good == true)
-        ts->set_failed_test_info(cvtest::TS::OK);
-    else
-        ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-}
-
-TEST(GpuMat_setTo, accuracy) { CV_GpuMatOpSetToTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_precomp.cpp b/modules/gpu/test/test_precomp.cpp
index 26a8f3f678..34acf2ae91 100644
--- a/modules/gpu/test/test_precomp.cpp
+++ b/modules/gpu/test/test_precomp.cpp
@@ -1 +1,42 @@
+/*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*/
+
 #include "test_precomp.hpp"
diff --git a/modules/gpu/test/test_precomp.hpp b/modules/gpu/test/test_precomp.hpp
index f114994f7a..5ddafaab39 100644
--- a/modules/gpu/test/test_precomp.hpp
+++ b/modules/gpu/test/test_precomp.hpp
@@ -1,13 +1,62 @@
+/*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_TEST_PRECOMP_HPP__
 #define __OPENCV_TEST_PRECOMP_HPP__
 
-#include <iostream>
+#include <cmath>
+#include <cstdio>
+#include <fstream>
+#include <sstream>
 #include <limits>
+#include <string>
+#include <algorithm>
+#include <iterator>
 #include "cvconfig.h"
 #include "opencv2/core/core.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/ts/ts.hpp"
 #include "opencv2/gpu/gpu.hpp"
+#include "test_gpu_base.hpp"
 
 #endif
diff --git a/modules/gpu/test/test_split_merge.cpp b/modules/gpu/test/test_split_merge.cpp
deleted file mode 100644
index ca5f4a9727..0000000000
--- a/modules/gpu/test/test_split_merge.cpp
+++ /dev/null
@@ -1,312 +0,0 @@
-/*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 GpuMaterials 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 bpied warranties, including, but not limited to, the bpied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#include "test_precomp.hpp"
-
-using namespace std;
-using namespace cv;
-
-////////////////////////////////////////////////////////////////////////////////
-// Merge
-
-struct CV_MergeTest : public cvtest::BaseTest
-{
-    void can_merge(size_t rows, size_t cols);
-    void can_merge_submatrixes(size_t rows, size_t cols);
-    void run(int);
-};
-
-
-void CV_MergeTest::can_merge(size_t rows, size_t cols)
-{
-    bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                     gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-    size_t depth_end = double_ok ? CV_64F : CV_32F;
-
-    for (size_t num_channels = 1; num_channels <= 4; ++num_channels)
-        for (size_t depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            vector<Mat> src;
-            for (size_t i = 0; i < num_channels; ++i)
-                src.push_back(Mat(rows, cols, depth, Scalar::all(static_cast<double>(i))));
-            
-            Mat dst(rows, cols, CV_MAKETYPE(depth, num_channels));   
-
-            cv::merge(src, dst);   
-
-            vector<gpu::GpuMat> dev_src;
-            for (size_t i = 0; i < num_channels; ++i)
-                dev_src.push_back(gpu::GpuMat(src[i]));
-
-            gpu::GpuMat dev_dst(rows, cols, CV_MAKETYPE(depth, num_channels));
-            cv::gpu::merge(dev_src, dev_dst); 
-
-            Mat host_dst = dev_dst;
-
-            double err = norm(dst, host_dst, NORM_INF);
-
-            if (err > 1e-3)
-            {
-                //ts->printf(cvtest::TS::CONSOLE, "\nNorm: %f\n", err);
-                //ts->printf(cvtest::TS::CONSOLE, "Depth: %d\n", depth);
-                //ts->printf(cvtest::TS::CONSOLE, "Rows: %d\n", rows);
-                //ts->printf(cvtest::TS::CONSOLE, "Cols: %d\n", cols);
-                //ts->printf(cvtest::TS::CONSOLE, "NumChannels: %d\n", num_channels);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-        }
-}
-
-
-void CV_MergeTest::can_merge_submatrixes(size_t rows, size_t cols)
-{
-    bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                     gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-    size_t depth_end = double_ok ? CV_64F : CV_32F;
-
-    for (size_t num_channels = 1; num_channels <= 4; ++num_channels)
-        for (size_t depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            vector<Mat> src;
-            for (size_t i = 0; i < num_channels; ++i) 
-            {
-                Mat m(rows * 2, cols * 2, depth, Scalar::all(static_cast<double>(i)));
-                src.push_back(m(Range(rows / 2, rows / 2 + rows), Range(cols / 2, cols / 2 + cols)));
-            }
-
-            Mat dst(rows, cols, CV_MAKETYPE(depth, num_channels));   
-
-            cv::merge(src, dst);   
-
-            vector<gpu::GpuMat> dev_src;
-            for (size_t i = 0; i < num_channels; ++i)
-                dev_src.push_back(gpu::GpuMat(src[i]));
-
-            gpu::GpuMat dev_dst(rows, cols, CV_MAKETYPE(depth, num_channels));
-            cv::gpu::merge(dev_src, dev_dst);
-
-            Mat host_dst = dev_dst;
-
-            double err = norm(dst, host_dst, NORM_INF);
-
-            if (err > 1e-3)
-            {
-                //ts->printf(cvtest::TS::CONSOLE, "\nNorm: %f\n", err);
-                //ts->printf(cvtest::TS::CONSOLE, "Depth: %d\n", depth);
-                //ts->printf(cvtest::TS::CONSOLE, "Rows: %d\n", rows);
-                //ts->printf(cvtest::TS::CONSOLE, "Cols: %d\n", cols);
-                //ts->printf(cvtest::TS::CONSOLE, "NumChannels: %d\n", num_channels);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-        }
-}
-
-void CV_MergeTest::run(int) 
-{
-    can_merge(1, 1);
-    can_merge(1, 7);
-    can_merge(53, 7);
-    can_merge_submatrixes(1, 1);
-    can_merge_submatrixes(1, 7);
-    can_merge_submatrixes(53, 7);
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Split
-
-struct CV_SplitTest : public cvtest::BaseTest
-{
-    void can_split(size_t rows, size_t cols);    
-    void can_split_submatrix(size_t rows, size_t cols);
-    void run(int);
-};
-
-void CV_SplitTest::can_split(size_t rows, size_t cols)
-{
-    bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                     gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-    size_t depth_end = double_ok ? CV_64F : CV_32F;
-
-    for (size_t num_channels = 1; num_channels <= 4; ++num_channels)
-        for (size_t depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            Mat src(rows, cols, CV_MAKETYPE(depth, num_channels), Scalar(1.0, 2.0, 3.0, 4.0));   
-            vector<Mat> dst;
-            cv::split(src, dst);   
-
-            gpu::GpuMat dev_src(src);
-            vector<gpu::GpuMat> dev_dst;
-            cv::gpu::split(dev_src, dev_dst);
-
-            if (dev_dst.size() != dst.size())
-            {
-                ts->printf(cvtest::TS::CONSOLE, "Bad output sizes");
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            }
-
-            for (size_t i = 0; i < num_channels; ++i)
-            {
-                Mat host_dst = dev_dst[i];
-                double err = norm(dst[i], host_dst, NORM_INF);
-
-                if (err > 1e-3)
-                {
-                    //ts->printf(cvtest::TS::CONSOLE, "\nNorm: %f\n", err);
-                    //ts->printf(cvtest::TS::CONSOLE, "Depth: %d\n", depth);
-                    //ts->printf(cvtest::TS::CONSOLE, "Rows: %d\n", rows);
-                    //ts->printf(cvtest::TS::CONSOLE, "Cols: %d\n", cols);
-                    //ts->printf(cvtest::TS::CONSOLE, "NumChannels: %d\n", num_channels);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-            }
-        }
-}
-
-void CV_SplitTest::can_split_submatrix(size_t rows, size_t cols)
-{
-    bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                     gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-    size_t depth_end = double_ok ? CV_64F : CV_32F;
-
-    for (size_t num_channels = 1; num_channels <= 4; ++num_channels)
-        for (size_t depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            Mat src_data(rows * 2, cols * 2, CV_MAKETYPE(depth, num_channels), Scalar(1.0, 2.0, 3.0, 4.0));   
-            Mat src(src_data(Range(rows / 2, rows / 2 + rows), Range(cols / 2, cols / 2 + cols)));
-            vector<Mat> dst;
-            cv::split(src, dst);   
-
-            gpu::GpuMat dev_src(src);
-            vector<gpu::GpuMat> dev_dst;
-            cv::gpu::split(dev_src, dev_dst);
-
-            if (dev_dst.size() != dst.size())
-            {
-                ts->printf(cvtest::TS::CONSOLE, "Bad output sizes");
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-            }
-
-            for (size_t i = 0; i < num_channels; ++i)
-            {
-                Mat host_dst = dev_dst[i];
-                double err = norm(dst[i], host_dst, NORM_INF);
-
-                if (err > 1e-3)
-                {
-                    //ts->printf(cvtest::TS::CONSOLE, "\nNorm: %f\n", err);
-                    //ts->printf(cvtest::TS::CONSOLE, "Depth: %d\n", depth);
-                    //ts->printf(cvtest::TS::CONSOLE, "Rows: %d\n", rows);
-                    //ts->printf(cvtest::TS::CONSOLE, "Cols: %d\n", cols);
-                    //ts->printf(cvtest::TS::CONSOLE, "NumChannels: %d\n", num_channels);
-                    ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                    return;
-                }
-            }
-        }
-}
-
-void CV_SplitTest::run(int)
-{
-    can_split(1, 1);
-    can_split(1, 7);
-    can_split(7, 53);
-    can_split_submatrix(1, 1);
-    can_split_submatrix(1, 7);
-    can_split_submatrix(7, 53);
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Split and merge
-
-struct CV_SplitMergeTest : public cvtest::BaseTest
-{
-    void can_split_merge(size_t rows, size_t cols);    
-    void run(int);
-};
-
-void CV_SplitMergeTest::can_split_merge(size_t rows, size_t cols) {
-    bool double_ok = gpu::TargetArchs::builtWith(gpu::NATIVE_DOUBLE) && 
-                     gpu::DeviceInfo().supports(gpu::NATIVE_DOUBLE);
-    size_t depth_end = double_ok ? CV_64F : CV_32F;
-
-    for (size_t num_channels = 1; num_channels <= 4; ++num_channels)
-        for (size_t depth = CV_8U; depth <= depth_end; ++depth)
-        {
-            Mat orig(rows, cols, CV_MAKETYPE(depth, num_channels), Scalar(1.0, 2.0, 3.0, 4.0));   
-            gpu::GpuMat dev_orig(orig);
-            vector<gpu::GpuMat> dev_vec;
-            cv::gpu::split(dev_orig, dev_vec);
-
-            gpu::GpuMat dev_final(rows, cols, CV_MAKETYPE(depth, num_channels));
-            cv::gpu::merge(dev_vec, dev_final);
-
-            double err = cv::norm((Mat)dev_orig, (Mat)dev_final, NORM_INF);
-            if (err > 1e-3)
-            {
-                //ts->printf(cvtest::TS::CONSOLE, "\nNorm: %f\n", err);
-                //ts->printf(cvtest::TS::CONSOLE, "Depth: %d\n", depth);
-                //ts->printf(cvtest::TS::CONSOLE, "Rows: %d\n", rows);
-                //ts->printf(cvtest::TS::CONSOLE, "Cols: %d\n", cols);
-                //ts->printf(cvtest::TS::CONSOLE, "NumChannels: %d\n", num_channels);
-                ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT);
-                return;
-            }
-        }
-}
-
-
-void CV_SplitMergeTest::run(int) 
-{
-    can_split_merge(1, 1);
-    can_split_merge(1, 7);
-    can_split_merge(7, 53);
-}
-
-
-TEST(merge, accuracy) { CV_MergeTest test; test.safe_run(); }
-TEST(split, accuracy) { CV_SplitTest test; test.safe_run(); }
-TEST(split, merge_consistency) { CV_SplitMergeTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_stereo_bm.cpp b/modules/gpu/test/test_stereo_bm.cpp
deleted file mode 100644
index 7a4806e6f5..0000000000
--- a/modules/gpu/test/test_stereo_bm.cpp
+++ /dev/null
@@ -1,131 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace cv::gpu;
-
-struct CV_GpuStereoBMTest : public cvtest::BaseTest
-{
-    void run_stress()
-    {                
-        RNG rng;
-
-        for(int i = 0; i < 10; ++i)
-        {
-            int winSize = cvRound(rng.uniform(2, 11)) * 2 + 1;
-
-            for(int j = 0; j < 10; ++j)
-            {
-                int ndisp = cvRound(rng.uniform(5, 32)) * 8;
-
-                for(int s = 0; s < 10; ++s)
-                {
-                    int w =  cvRound(rng.uniform(1024, 2048));
-                    int h =  cvRound(rng.uniform(768, 1152));
-
-                    for(int p = 0; p < 2; ++p)
-                    {
-                        //int winSize = winsz[i];
-                        //int disp = disps[j];
-                        Size imgSize(w, h);//res[s];
-                        int preset = p;
-
-                        printf("Preset = %d, nidsp = %d, winsz = %d, width = %d, height = %d\n", p, ndisp, winSize, imgSize.width, imgSize.height);
-
-                        GpuMat l(imgSize, CV_8U);
-                        GpuMat r(imgSize, CV_8U);
-
-                        GpuMat disparity;
-                        StereoBM_GPU bm(preset, ndisp, winSize);
-                        bm(l, r, disparity);
-
-            
-                    }
-                }
-            }
-        }
-    }
-
-    void run(int )
-    {
-        /*run_stress();
-        return;*/
-
-	    cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0);
-	    cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0);
-	    cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0);
-
-        if (img_l.empty() || img_r.empty() || img_reference.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        cv::gpu::GpuMat disp;
-        cv::gpu::StereoBM_GPU bm(0, 128, 19);
-        bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp);
-
-        disp.convertTo(disp, img_reference.type());
-        double norm = cv::norm((Mat)disp, img_reference, cv::NORM_INF);
-
-        //cv::imwrite(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", disp);
-
-        /*cv::imshow("disp", disp);
-        cv::imshow("img_reference", img_reference);
-
-        cv::Mat diff = (cv::Mat)disp - (cv::Mat)img_reference;
-        cv::imshow("diff", diff);
-        cv::waitKey();*/
-
-        if (norm >= 100)
-        {
-            ts->printf(cvtest::TS::LOG, "\nStereoBM norm = %f\n", norm);
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-};
-
-TEST(StereoBM, regression) { CV_GpuStereoBMTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_stereo_bm_async.cpp b/modules/gpu/test/test_stereo_bm_async.cpp
deleted file mode 100644
index f9632dd283..0000000000
--- a/modules/gpu/test/test_stereo_bm_async.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-using namespace cv;
-using namespace std;
-
-struct CV_AsyncStereoBMTest : public cvtest::BaseTest
-{
-    void run( int /* start_from */)
-    {
-	    cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-L.png", 0);
-	    cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-R.png", 0);
-	    cv::Mat img_reference = cv::imread(std::string(ts->get_data_path()) + "stereobm/aloe-disp.png", 0);
-
-        if (img_l.empty() || img_r.empty() || img_reference.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        cv::gpu::GpuMat disp;
-        cv::gpu::StereoBM_GPU bm(0, 128, 19);
-
-        cv::gpu::Stream stream;
-
-        for (size_t i = 0; i < 50; i++)
-        {
-            bm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp, stream);
-        }
-
-        stream.waitForCompletion();
-        disp.convertTo(disp, img_reference.type());
-        double norm = cv::norm((Mat)disp, img_reference, cv::NORM_INF);
-
-        if (norm >= 100)
-        {
-            ts->printf(cvtest::TS::LOG, "\nStereoBM norm = %f\n", norm);
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-};
-
-TEST(StereoBM, async) { CV_AsyncStereoBMTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_stereo_bp.cpp b/modules/gpu/test/test_stereo_bp.cpp
deleted file mode 100644
index 7788917375..0000000000
--- a/modules/gpu/test/test_stereo_bp.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-struct CV_GpuStereoBPTest : public cvtest::BaseTest
-{
-    void run(int)
-    {
-        cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-L.png");
-        cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-R.png");
-        cv::Mat img_template = cv::imread(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", 0);
-
-        if (img_l.empty() || img_r.empty() || img_template.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        {cv::Mat temp; cv::cvtColor(img_l, temp, CV_BGR2BGRA); cv::swap(temp, img_l);}
-        {cv::Mat temp; cv::cvtColor(img_r, temp, CV_BGR2BGRA); cv::swap(temp, img_r);}
-
-        cv::gpu::StereoBeliefPropagation bpm(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
-        cv::gpu::GpuMat disp;
-
-        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp);
-
-        //cv::imwrite(std::string(ts->get_data_path()) + "stereobp/aloe-disp.png", disp);
-
-        disp.convertTo(disp, img_template.type());
-
-        double norm = cv::norm((cv::Mat)disp, img_template, cv::NORM_INF);
-	    if (norm >= 0.5)
-        {
-	        ts->printf(cvtest::TS::LOG, "\nStereoBP norm = %f\n", norm);
-	        ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-	        return;
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-};
-
-TEST(StereoBP, regression) { CV_GpuStereoBPTest test; test.safe_run(); }
diff --git a/modules/gpu/test/test_stereo_csbp.cpp b/modules/gpu/test/test_stereo_csbp.cpp
deleted file mode 100644
index a2f794f21b..0000000000
--- a/modules/gpu/test/test_stereo_csbp.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*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*/
-
-#include "test_precomp.hpp"
-
-struct CV_GpuStereoCSBPTest : public cvtest::BaseTest
-{
-    void run(int )
-    {
-        cv::Mat img_l = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-L.png");
-        cv::Mat img_r = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-R.png");
-
-        cv::Mat img_template;
-
-        if (cv::gpu::TargetArchs::builtWith(cv::gpu::FEATURE_SET_COMPUTE_20) &&
-            cv::gpu::DeviceInfo().supports(cv::gpu::FEATURE_SET_COMPUTE_20))
-            img_template = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-disp.png", CV_LOAD_IMAGE_GRAYSCALE);
-        else
-            img_template = cv::imread(std::string(ts->get_data_path()) + "csstereobp/aloe-disp_CC1X.png", CV_LOAD_IMAGE_GRAYSCALE);
-
-        if (img_l.empty() || img_r.empty() || img_template.empty())
-        {
-            ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
-            return;
-        }
-
-        {cv::Mat temp; cv::cvtColor(img_l, temp, CV_BGR2BGRA); cv::swap(temp, img_l);}
-        {cv::Mat temp; cv::cvtColor(img_r, temp, CV_BGR2BGRA); cv::swap(temp, img_r);}
-
-        cv::gpu::GpuMat disp;
-        cv::gpu::StereoConstantSpaceBP bpm(128, 16, 4, 4);
-
-        bpm(cv::gpu::GpuMat(img_l), cv::gpu::GpuMat(img_r), disp);
-
-        //cv::imwrite(std::string(ts->get_data_path()) + "csstereobp/aloe-disp_CC1X.png", cv::Mat(disp));
-
-        disp.convertTo(disp, img_template.type());
-
-        double norm = cv::norm((cv::Mat)disp, img_template, cv::NORM_INF);
-        if (norm >= 1.5)
-        {
-            ts->printf(cvtest::TS::LOG, "\nConstantSpaceStereoBP norm = %f\n", norm);
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-            return;
-        }
-
-        ts->set_failed_test_info(cvtest::TS::OK);
-    }
-};
-
-TEST(StereoConstantSpaceBP, regression) { CV_GpuStereoCSBPTest test; test.safe_run(); }
diff --git a/modules/highgui/CMakeLists.txt b/modules/highgui/CMakeLists.txt
index 2e12aa6285..b0975d7622 100644
--- a/modules/highgui/CMakeLists.txt
+++ b/modules/highgui/CMakeLists.txt
@@ -211,13 +211,22 @@ if(APPLE)
     endif()
 endif(APPLE)
 
-if(ANDROID)
+if(WITH_ANDROID_CAMERA)
   include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../androidcamera/include")
   set(highgui_srcs ${highgui_srcs} src/cap_android.cpp)
   add_definitions(-DHAVE_ANDROID_NATIVE_CAMERA)
   set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES} opencv_androidcamera)
 endif()
 
+#XIMEA API
+if(HAVE_XIMEA AND XIMEA_FOUND)
+   set(highgui_srcs ${highgui_srcs} src/cap_ximea.cpp)
+   include_directories(${XIMEA_PATH})
+   link_directories(${XIMEA_LIBRARY_DIR})
+   set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES} m3api)
+   set(highgui_srcs ${highgui_srcs} src/cap_ximea.cpp)
+endif()
+
 if(COMMAND get_module_external_sources)
     set( lib_srcs "${highgui_srcs}" )
     set( lib_int_hdrs "${highgui_hdrs}" )
@@ -263,21 +272,11 @@ if (BUILD_SHARED_LIBS)
 	if(MSVC)
 		set_target_properties(${the_target} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
 	else()
-		add_definitions(-DCVAPI_EXPORTS) 		
+		add_definitions(-DCVAPI_EXPORTS)
 	endif()
 endif()
 
-if(PCHSupport_FOUND AND USE_PRECOMPILED_HEADERS)
-    set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
-    if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-        if(${CMAKE_GENERATOR} MATCHES "Visual*")
-            set(${the_target}_pch "src/precomp.cpp")
-        endif()            
-        add_native_precompiled_header(${the_target} ${pch_header})
-    elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-        add_precompiled_header(${the_target} ${pch_header})
-    endif()
-endif()
+add_opencv_precompiled_headers(${the_target})
 
 # For dynamic link numbering convenions
 if(NOT ANDROID)
@@ -288,7 +287,7 @@ if(NOT ANDROID)
         )
 endif()
 
-set_target_properties(${the_target} PROPERTIES OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}" )	
+set_target_properties(${the_target} PROPERTIES OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}" )
 
 # Additional target properties
 set_target_properties(${the_target} PROPERTIES
@@ -333,7 +332,7 @@ if(NOT ZLIB_FOUND)
     add_dependencies(${the_target} zlib)
 endif()
 
-if(ANDROID)
+if(WITH_ANDROID_CAMERA)
     add_dependencies(${the_target} opencv_androidcamera)
 endif()
 
@@ -362,11 +361,11 @@ endif()
 
 install(TARGETS ${the_target}
     RUNTIME DESTINATION bin COMPONENT main
-    LIBRARY DESTINATION lib COMPONENT main
-    ARCHIVE DESTINATION lib COMPONENT main)
+    LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
+    ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
 
 install(FILES ${highgui_ext_hdrs}
-        DESTINATION include/opencv2/highgui
+        DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/highgui
         COMPONENT main)
 
 
@@ -377,7 +376,7 @@ if(BUILD_TESTS)
                       "${CMAKE_CURRENT_BINARY_DIR}")
 
   set(test_deps opencv_ts opencv_highgui opencv_imgproc)
-  if(ANDROID)
+  if(WITH_ANDROID_CAMERA)
     set(test_deps ${test_deps} opencv_androidcamera)
   endif()
 
@@ -398,27 +397,17 @@ if(BUILD_TESTS)
 
   add_executable(${the_target} ${test_srcs} ${test_hdrs})
 
-  if(PCHSupport_FOUND AND USE_PRECOMPILED_HEADERS)
-      set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/test/test_precomp.hpp)
-      if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
-          if(${CMAKE_GENERATOR} MATCHES "Visual*")
-              set(${the_target}_pch "test/test_precomp.cpp")
-          endif()            
-          add_native_precompiled_header(${the_target} ${pch_header})
-      elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
-          add_precompiled_header(${the_target} ${pch_header})
-      endif()
-  endif()
+  add_opencv_precompiled_headers(${the_target})
 
   # Additional target properties
   set_target_properties(${the_target} PROPERTIES
       DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
       RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}"
       )
-	
+
   if(ENABLE_SOLUTION_FOLDERS)
-	  set_target_properties(${the_target} PROPERTIES FOLDER "tests")
-  endif()	
+    set_target_properties(${the_target} PROPERTIES FOLDER "tests")
+  endif()
 
   add_dependencies(${the_target} ${test_deps})
 
diff --git a/modules/highgui/doc/qt_new_functions.rst b/modules/highgui/doc/qt_new_functions.rst
index 534b9bf033..8fcb050b0e 100644
--- a/modules/highgui/doc/qt_new_functions.rst
+++ b/modules/highgui/doc/qt_new_functions.rst
@@ -230,9 +230,9 @@ createOpenGLCallback
 ------------------------
 Creates a callback function called to draw OpenGL on top the the image display by ``windowname``.
 
-.. ocv:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1)
+.. ocv:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata =NULL, double angle=-1, double zmin=-1, double zmax=-1)
 
-.. ocv:cfunction:: void cvCreateOpenGLCallback( const char* windowName, CvOpenGLCallback callbackOpenGL, void* userdata=NULL, double angle=-1, double zmin=-1, double zmax=-1
+.. ocv:cfunction:: void cvCreateOpenGLCallback( const char* windowName, CvOpenGLCallback callbackOpenGL, void* userdata=NULL, double angle=-1, double zmin=-1, double zmax=-1 )
 
     :param window_name: Name of the window.
 
@@ -308,9 +308,9 @@ createButton
 ----------------
 Attaches a button to the control panel.
 
-.. ocv:function:: createButton( const string& button_name CV_DEFAULT(NULL),ButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL), int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0))
+.. ocv:function:: createButton( const string& button_name=NULL, ButtonCallback on_change=NULL, void* userdata=NULL, int button_type=CV_PUSH_BUTTON, int initial_button_state=0 )
 
-.. ocv:cfunction:: cvCreateButton( const char* buttonName=NULL, CvButtonCallback onChange=NULL, void* userdata=NULL, int buttonType=CV_PUSH_BUTTON, int initialButtonState=0
+.. ocv:cfunction:: cvCreateButton( const char* buttonName=NULL, CvButtonCallback onChange=NULL, void* userdata=NULL, int buttonType=CV_PUSH_BUTTON, int initialButtonState=0 )
 
     :param  button_name: Name of the button.
 
diff --git a/modules/highgui/doc/reading_and_writing_images_and_video.rst b/modules/highgui/doc/reading_and_writing_images_and_video.rst
index 1af534ae1e..44e74b4cea 100644
--- a/modules/highgui/doc/reading_and_writing_images_and_video.rst
+++ b/modules/highgui/doc/reading_and_writing_images_and_video.rst
@@ -9,14 +9,18 @@ Reads an image from a buffer in memory.
 
 .. ocv:function:: Mat imdecode( InputArray buf,  int flags )
 
+.. 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 of vector of bytes.
+    :param buf: Input array or vector of bytes.
 
     :param flags: The same flags as in  :ocv:func:`imread` .
     
 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 is returned.
+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.
@@ -27,6 +31,8 @@ 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=NULL )
+
 .. ocv:pyfunction:: cv2.imencode(ext, img, buf[, params]) -> retval
 
     :param ext: File extension that defines the output format.
@@ -41,6 +47,8 @@ The function compresses the image and stores it in the memory buffer that is res
 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.
@@ -218,7 +226,7 @@ Closes video file or capturing device.
 
 .. ocv:pyfunction:: cv2.VideoCapture.release()
 
-.. ocv:cfunction: void cvReleaseCapture(CvCapture** capture)
+.. ocv:cfunction:: void cvReleaseCapture(CvCapture** capture)
 
 The methods are automatically called by subsequent :ocv:func:`VideoCapture::open` and by ``VideoCapture`` destructor.
 
@@ -233,7 +241,7 @@ Grabs the next frame from video file or capturing device.
 
 .. ocv:pyfunction:: cv2.VideoCapture.grab() -> successFlag
 
-.. ocv:cfunction: int cvGrabFrame(CvCapture* capture)
+.. ocv:cfunction:: int cvGrabFrame(CvCapture* capture)
 
 .. ocv:pyoldfunction:: cv.GrabFrame(capture) -> int
 
@@ -252,7 +260,7 @@ Decodes and returns the grabbed video frame.
 
 .. ocv:pyfunction:: cv2.VideoCapture.retrieve([image[, channel]]) -> successFlag, image
 
-.. ocv:cfunction: IplImage* cvRetrieveFrame(CvCapture* capture)
+.. ocv:cfunction:: IplImage* cvRetrieveFrame(CvCapture* capture)
 
 .. ocv:pyoldfunction:: cv.RetrieveFrame(capture) -> iplimage
 
@@ -266,11 +274,12 @@ VideoCapture::read
 Grabs, decodes and returns the next video frame.
 
 .. ocv:function:: VideoCapture& VideoCapture::operator >> (Mat& image)
+
 .. ocv:function:: bool VideoCapture::read(Mat& image)
 
 .. ocv:pyfunction:: cv2.VideoCapture.read([image]) -> successFlag, image
 
-.. ocv:cfunction: IplImage* cvQueryFrame(CvCapture* capture)
+.. ocv:cfunction:: IplImage* cvQueryFrame(CvCapture* capture)
 
 .. ocv:pyoldfunction:: cv.QueryFrame(capture) -> iplimage
 
@@ -288,6 +297,7 @@ Returns the specified ``VideoCapture`` property
 .. ocv:pyfunction:: cv2.VideoCapture.get(propId) -> retval
 
 .. ocv:cfunction:: double cvGetCaptureProperty( CvCapture* capture, int propId )
+
 .. ocv:pyoldfunction:: cv.GetCaptureProperty(capture, propId)->double
 
 
@@ -343,6 +353,7 @@ Sets a property in the ``VideoCapture``.
 .. ocv:pyfunction:: cv2.VideoCapture.set(propId, value) -> retval
 
 .. ocv:cfunction:: int cvSetCaptureProperty( CvCapture* capture, int propId, double value )
+
 .. ocv:pyoldfunction:: cv.SetCaptureProperty(capture, propId, value)->None
 
     :param propId: Property identifier. It can be one of the following:
@@ -402,6 +413,7 @@ VideoWriter::VideoWriter
 VideoWriter constructors
 
 .. ocv:function:: VideoWriter::VideoWriter()
+
 .. ocv:function:: VideoWriter::VideoWriter(const string& filename, int fourcc, double fps, Size frameSize, bool isColor=true)
 
 .. ocv:pyfunction:: cv2.VideoWriter([filename, fourcc, fps, frameSize[, isColor]]) -> <VideoWriter object>
@@ -440,7 +452,7 @@ VideoWriter::open
 -----------------
 Initializes or reinitializes video writer.
 
-.. ocv:function: bool VideoWriter::open(const string& filename, int fourcc, double fps, Size frameSize, bool isColor=true)
+.. ocv:function:: bool VideoWriter::open(const string& filename, int fourcc, double fps, Size frameSize, bool isColor=true)
 
 .. ocv:pyfunction:: cv2.VideoWriter.open(filename, fourcc, fps, frameSize[, isColor]) -> retval
 
@@ -451,7 +463,7 @@ VideoWriter::isOpened
 ---------------------
 Returns true if video writer has been successfully initialized.
 
-.. ocv:function: bool VideoWriter::isOpened()
+.. ocv:function:: bool VideoWriter::isOpened()
 
 .. ocv:pyfunction:: cv2.VideoWriter.isOpened() -> retval
 
@@ -461,6 +473,7 @@ VideoWriter::write
 Writes the next video frame
 
 .. ocv:function:: VideoWriter& VideoWriter::operator << (const Mat& image)
+
 .. ocv:function:: void VideoWriter::write(const Mat& image)
 
 .. ocv:pyfunction:: cv2.VideoWriter.write(image) -> None
diff --git a/modules/highgui/doc/user_interface.rst b/modules/highgui/doc/user_interface.rst
index 1fc919f546..e897f936c5 100644
--- a/modules/highgui/doc/user_interface.rst
+++ b/modules/highgui/doc/user_interface.rst
@@ -156,7 +156,7 @@ Moves window to the specified position
 
 
 ResizeWindow
-----------
+------------
 Resizes window to the specified size
 
 .. ocv:cfunction:: void cvResizeWindow( const char* name, int width, int height )
diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp
index 094aeda25f..0f7e5d46e7 100644
--- a/modules/highgui/include/opencv2/highgui/highgui.hpp
+++ b/modules/highgui/include/opencv2/highgui/highgui.hpp
@@ -101,6 +101,30 @@ CV_EXPORTS int createTrackbar( const string& trackbarname, const string& winname
 CV_EXPORTS_W int getTrackbarPos( const string& trackbarname, const string& winname );
 CV_EXPORTS_W void setTrackbarPos( const string& trackbarname, const string& winname, int pos );
 
+enum
+{
+    EVENT_MOUSEMOVE      =0,
+    EVENT_LBUTTONDOWN    =1,
+    EVENT_RBUTTONDOWN    =2,
+    EVENT_MBUTTONDOWN    =3,
+    EVENT_LBUTTONUP      =4,
+    EVENT_RBUTTONUP      =5,
+    EVENT_MBUTTONUP      =6,
+    EVENT_LBUTTONDBLCLK  =7,
+    EVENT_RBUTTONDBLCLK  =8,
+    EVENT_MBUTTONDBLCLK  =9
+};
+
+enum
+{
+    EVENT_FLAG_LBUTTON   =1,
+    EVENT_FLAG_RBUTTON   =2,
+    EVENT_FLAG_MBUTTON   =4,
+    EVENT_FLAG_CTRLKEY   =8,
+    EVENT_FLAG_SHIFTKEY  =16,
+    EVENT_FLAG_ALTKEY    =32
+};
+        
 typedef void (*MouseCallback )(int event, int x, int y, int flags, void* param);
 
 //! assigns callback for mouse events
diff --git a/modules/highgui/include/opencv2/highgui/highgui_c.h b/modules/highgui/include/opencv2/highgui/highgui_c.h
index 2ad1fd08d6..52fa3a8060 100644
--- a/modules/highgui/include/opencv2/highgui/highgui_c.h
+++ b/modules/highgui/include/opencv2/highgui/highgui_c.h
@@ -54,16 +54,16 @@ extern "C" {
 //YV
 //-----------New for Qt
 /* For font */
-enum {	CV_FONT_LIGHT 			= 25,//QFont::Light,
-		CV_FONT_NORMAL 			= 50,//QFont::Normal,
-		CV_FONT_DEMIBOLD 		= 63,//QFont::DemiBold,
-		CV_FONT_BOLD 			= 75,//QFont::Bold,
-		CV_FONT_BLACK 			= 87 //QFont::Black
+enum {  CV_FONT_LIGHT           = 25,//QFont::Light,
+        CV_FONT_NORMAL          = 50,//QFont::Normal,
+        CV_FONT_DEMIBOLD        = 63,//QFont::DemiBold,
+        CV_FONT_BOLD            = 75,//QFont::Bold,
+        CV_FONT_BLACK           = 87 //QFont::Black
 };
 
-enum {	CV_STYLE_NORMAL			= 0,//QFont::StyleNormal,
-		CV_STYLE_ITALIC 		= 1,//QFont::StyleItalic,
-		CV_STYLE_OBLIQUE 		= 2 //QFont::StyleOblique
+enum {  CV_STYLE_NORMAL         = 0,//QFont::StyleNormal,
+        CV_STYLE_ITALIC         = 1,//QFont::StyleItalic,
+        CV_STYLE_OBLIQUE        = 2 //QFont::StyleOblique
 };
 /* ---------*/
 
@@ -98,23 +98,23 @@ CVAPI(int) cvStartWindowThread();
 // ---------  YV ---------
 enum
 {
-	//These 3 flags are used by cvSet/GetWindowProperty
-	CV_WND_PROP_FULLSCREEN = 0,//to change/get window's fullscreen property
-	CV_WND_PROP_AUTOSIZE   = 1,//to change/get window's autosize property
-	CV_WND_PROP_ASPECTRATIO= 2,//to change/get window's aspectratio property
-	//
-	//These 2 flags are used by cvNamedWindow and cvSet/GetWindowProperty
-	CV_WINDOW_NORMAL       = 0x00000000,//the user can resize the window (no constraint)  / also use to switch a fullscreen window to a normal size
-	CV_WINDOW_AUTOSIZE 	   = 0x00000001,//the user cannot resize the window, the size is constrainted by the image displayed
-	//
-	//Those flags are only for Qt
-	CV_GUI_EXPANDED 		= 0x00000000,//status bar and tool bar
-	CV_GUI_NORMAL 			= 0x00000010,//old fashious way
-	//
-	//These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty
-	CV_WINDOW_FULLSCREEN   = 1,//change the window to fullscreen
-	CV_WINDOW_FREERATIO	   = 0x00000100,//the image expends as much as it can (no ratio constraint)
-	CV_WINDOW_KEEPRATIO    = 0x00000000//the ration image is respected.
+    //These 3 flags are used by cvSet/GetWindowProperty
+    CV_WND_PROP_FULLSCREEN = 0,//to change/get window's fullscreen property
+    CV_WND_PROP_AUTOSIZE   = 1,//to change/get window's autosize property
+    CV_WND_PROP_ASPECTRATIO= 2,//to change/get window's aspectratio property
+    //
+    //These 2 flags are used by cvNamedWindow and cvSet/GetWindowProperty
+    CV_WINDOW_NORMAL       = 0x00000000,//the user can resize the window (no constraint)  / also use to switch a fullscreen window to a normal size
+    CV_WINDOW_AUTOSIZE     = 0x00000001,//the user cannot resize the window, the size is constrainted by the image displayed
+    //
+    //Those flags are only for Qt
+    CV_GUI_EXPANDED         = 0x00000000,//status bar and tool bar
+    CV_GUI_NORMAL           = 0x00000010,//old fashious way
+    //
+    //These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty
+    CV_WINDOW_FULLSCREEN   = 1,//change the window to fullscreen
+    CV_WINDOW_FREERATIO    = 0x00000100,//the image expends as much as it can (no ratio constraint)
+    CV_WINDOW_KEEPRATIO    = 0x00000000//the ration image is respected.
 };
 
 /* create window */
@@ -162,26 +162,26 @@ CVAPI(void) cvSetTrackbarPos( const char* trackbar_name, const char* window_name
 
 enum
 {
-	CV_EVENT_MOUSEMOVE      =0,
-	CV_EVENT_LBUTTONDOWN    =1,
-	CV_EVENT_RBUTTONDOWN    =2,
-	CV_EVENT_MBUTTONDOWN    =3,
-	CV_EVENT_LBUTTONUP      =4,
-	CV_EVENT_RBUTTONUP      =5,
-	CV_EVENT_MBUTTONUP      =6,
-	CV_EVENT_LBUTTONDBLCLK  =7,
-	CV_EVENT_RBUTTONDBLCLK  =8,
-	CV_EVENT_MBUTTONDBLCLK  =9
+    CV_EVENT_MOUSEMOVE      =0,
+    CV_EVENT_LBUTTONDOWN    =1,
+    CV_EVENT_RBUTTONDOWN    =2,
+    CV_EVENT_MBUTTONDOWN    =3,
+    CV_EVENT_LBUTTONUP      =4,
+    CV_EVENT_RBUTTONUP      =5,
+    CV_EVENT_MBUTTONUP      =6,
+    CV_EVENT_LBUTTONDBLCLK  =7,
+    CV_EVENT_RBUTTONDBLCLK  =8,
+    CV_EVENT_MBUTTONDBLCLK  =9
 };
 
 enum
 {
-	CV_EVENT_FLAG_LBUTTON   =1,
-	CV_EVENT_FLAG_RBUTTON   =2,
-	CV_EVENT_FLAG_MBUTTON   =4,
-	CV_EVENT_FLAG_CTRLKEY   =8,
-	CV_EVENT_FLAG_SHIFTKEY  =16,
-	CV_EVENT_FLAG_ALTKEY    =32
+    CV_EVENT_FLAG_LBUTTON   =1,
+    CV_EVENT_FLAG_RBUTTON   =2,
+    CV_EVENT_FLAG_MBUTTON   =4,
+    CV_EVENT_FLAG_CTRLKEY   =8,
+    CV_EVENT_FLAG_SHIFTKEY  =16,
+    CV_EVENT_FLAG_ALTKEY    =32
 };
 
 typedef void (CV_CDECL *CvMouseCallback )(int event, int x, int y, int flags, void* param);
@@ -193,15 +193,15 @@ CVAPI(void) cvSetMouseCallback( const char* window_name, CvMouseCallback on_mous
 enum
 {
 /* 8bit, color or not */
-	CV_LOAD_IMAGE_UNCHANGED  =-1,
+    CV_LOAD_IMAGE_UNCHANGED  =-1,
 /* 8bit, gray */
-	CV_LOAD_IMAGE_GRAYSCALE  =0,
+    CV_LOAD_IMAGE_GRAYSCALE  =0,
 /* ?, color */
-	CV_LOAD_IMAGE_COLOR      =1,
+    CV_LOAD_IMAGE_COLOR      =1,
 /* any depth, ? */
-	CV_LOAD_IMAGE_ANYDEPTH   =2,
+    CV_LOAD_IMAGE_ANYDEPTH   =2,
 /* ?, any color */
-	CV_LOAD_IMAGE_ANYCOLOR   =4
+    CV_LOAD_IMAGE_ANYCOLOR   =4
 };
 
 /* load image from file
@@ -215,9 +215,9 @@ CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD
 
 enum
 {
-	CV_IMWRITE_JPEG_QUALITY =1,
-	CV_IMWRITE_PNG_COMPRESSION =16,
-	CV_IMWRITE_PXM_BINARY =32
+    CV_IMWRITE_JPEG_QUALITY =1,
+    CV_IMWRITE_PNG_COMPRESSION =16,
+    CV_IMWRITE_PXM_BINARY =32
 };
 
 /* save image to file */
@@ -234,8 +234,8 @@ CVAPI(CvMat*) cvEncodeImage( const char* ext, const CvArr* image,
 
 enum
 {
-	CV_CVTIMG_FLIP      =1,
-	CV_CVTIMG_SWAP_RB   =2
+    CV_CVTIMG_FLIP      =1,
+    CV_CVTIMG_SWAP_RB   =2
 };
 
 /* utility function: convert one image to another with optional vertical flip */
@@ -256,38 +256,40 @@ CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
 
 enum
 {
-	CV_CAP_ANY      =0,     // autodetect
+    CV_CAP_ANY      =0,     // autodetect
 
-	CV_CAP_MIL      =100,   // MIL proprietary drivers
+    CV_CAP_MIL      =100,   // MIL proprietary drivers
 
-	CV_CAP_VFW      =200,   // platform native
-	CV_CAP_V4L      =200,
-	CV_CAP_V4L2     =200,
+    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_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_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_QT       =500,   // QuickTime
 
-	CV_CAP_UNICAP   =600,   // Unicap drivers
+    CV_CAP_UNICAP   =600,   // Unicap drivers
 
-	CV_CAP_DSHOW    =700,   // DirectShow (via videoInput)
+    CV_CAP_DSHOW    =700,   // DirectShow (via videoInput)
 
-	CV_CAP_PVAPI    =800,   // PvAPI, Prosilica GigE SDK
+    CV_CAP_PVAPI    =800,   // PvAPI, Prosilica GigE SDK
 
-	CV_CAP_OPENNI   =900,   // OpenNI (for Kinect)
+    CV_CAP_OPENNI   =900,   // OpenNI (for Kinect)
 
-	CV_CAP_ANDROID  =1000   // Android
+    CV_CAP_ANDROID  =1000,  // Android
+    
+    CV_CAP_XIAPI    =1100   // XIMEA Camera API
 };
 
 /* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */
@@ -318,26 +320,26 @@ enum
     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_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_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
@@ -349,8 +351,9 @@ enum
     CV_CAP_PROP_WHITE_BALANCE_RED_V =26,
     CV_CAP_PROP_MAX_DC1394    =27,
     CV_CAP_PROP_AUTOGRAB      =1024, // property for highgui class CvCapture_Android only
-    CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING=1025, // tricky property, returns cpnst char* indeed
-	// OpenNI map generators
+    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 = 0,
     CV_CAP_OPENNI_IMAGE_GENERATOR = 1 << 31,
     CV_CAP_OPENNI_GENERATORS_MASK = 1 << 31,
@@ -360,15 +363,41 @@ enum
     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_ON    = 104, // flag
+    CV_CAP_PROP_OPENNI_REGISTRATION_ON  = 104, // flag
+    CV_CAP_PROP_OPENNI_REGISTRATION     = CV_CAP_PROP_OPENNI_REGISTRATION_ON, // 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_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_ON = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION_ON,
     
     // Properties of cameras available through GStreamer interface
-    CV_CAP_GSTREAMER_QUEUE_LENGTH	= 200, // default is 1
-    CV_CAP_PROP_PVAPI_MULTICASTIP       = 300 // ip for anable multicast master mode. 0 for disable multicast
+    CV_CAP_GSTREAMER_QUEUE_LENGTH   = 200, // default is 1
+    CV_CAP_PROP_PVAPI_MULTICASTIP   = 300, // ip for anable multicast master mode. 0 for disable multicast
+    
+    // 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
 };
 
 enum
@@ -415,7 +444,7 @@ typedef struct CvVideoWriter CvVideoWriter;
 
 CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4)
 {
-	return (c1 & 255) + ((c2 & 255) << 8) + ((c3 &255) << 16) + ((c4 & 255) << 24);
+    return (c1 & 255) + ((c2 & 255) << 8) + ((c3 &255) << 16) + ((c4 & 255) << 24);
 }
 
 #define CV_FOURCC_PROMPT -1  /* Open Codec Selection Dialog (Windows only) */
diff --git a/modules/highgui/src/cap.cpp b/modules/highgui/src/cap.cpp
index 2fab8c969b..fa9f9f9da6 100644
--- a/modules/highgui/src/cap.cpp
+++ b/modules/highgui/src/cap.cpp
@@ -127,8 +127,15 @@ CV_IMPL CvCapture * cvCreateCameraCapture (int index)
         CV_CAP_MIL,
         CV_CAP_QT,
         CV_CAP_UNICAP,
+#ifdef HAVE_OPENNI
         CV_CAP_OPENNI,
+#endif
+#ifdef HAVE_ANDROID_NATIVE_CAMERA
         CV_CAP_ANDROID,
+#endif
+#ifdef HAVE_XIMEA
+        CV_CAP_XIAPI,
+#endif
         -1
     };
 
@@ -234,36 +241,43 @@ CV_IMPL CvCapture * cvCreateCameraCapture (int index)
 
         #ifdef HAVE_UNICAP
         case CV_CAP_UNICAP:
-        capture = cvCreateCameraCapture_Unicap (index);
-        if (capture)
-            return capture;
+            capture = cvCreateCameraCapture_Unicap (index);
+            if (capture)
+                return capture;
         break;
         #endif
         
         #ifdef HAVE_PVAPI
         case CV_CAP_PVAPI:
-        capture = cvCreateCameraCapture_PvAPI (index);
-        if (capture)
-            return capture;
+            capture = cvCreateCameraCapture_PvAPI (index);
+            if (capture)
+                return capture;
         break;
         #endif
 
         #ifdef HAVE_OPENNI
         case CV_CAP_OPENNI:
-        capture = cvCreateCameraCapture_OpenNI (index);
-        if (capture)
-            return capture;
+            capture = cvCreateCameraCapture_OpenNI (index);
+            if (capture)
+                return capture;
         break;
         #endif
 
-		#ifdef HAVE_ANDROID_NATIVE_CAMERA
+        #ifdef HAVE_ANDROID_NATIVE_CAMERA
         case CV_CAP_ANDROID:
-          capture = cvCreateCameraCapture_Android (index);
-        if (capture)
-            return capture;
+            capture = cvCreateCameraCapture_Android (index);
+            if (capture)
+                return capture;
+        break;
+        #endif
+        
+        #ifdef HAVE_XIMEA
+        case CV_CAP_XIAPI:
+            capture = cvCreateCameraCapture_Ximea (index);
+            if (capture)
+                return capture;
         break;
         #endif
-
         }
     }
 
diff --git a/modules/highgui/src/cap_android.cpp b/modules/highgui/src/cap_android.cpp
index 8aabf67b60..440ddc392c 100644
--- a/modules/highgui/src/cap_android.cpp
+++ b/modules/highgui/src/cap_android.cpp
@@ -86,8 +86,18 @@ protected:
     //raw from camera
     int m_width;
     int m_height;
-    unsigned char *m_frameYUV420i;
-    unsigned char *m_frameYUV420inext;
+    unsigned char *m_frameYUV420;
+    unsigned char *m_frameYUV420next;
+
+    enum YUVformat
+    {
+        noformat = 0,
+        yuv420sp,
+        yuv420i,
+        yuvUnknown
+    };
+
+    YUVformat m_frameFormat;
 
     void setFrame(const void* buffer, int bufferSize);
 
@@ -117,9 +127,9 @@ private:
     volatile bool m_waitingNextFrame;
     volatile bool m_shouldAutoGrab;
 
-    void prepareCacheForYUV420i(int width, int height);
-    static bool convertYUV420i2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat);
-    static bool convertYUV420i2BGR(int width, int height, const unsigned char* yuv, cv::Mat& resmat, bool inRGBorder, bool withAlpha);
+    void prepareCacheForYUV(int width, int height);
+    bool convertYUV2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat);
+    bool convertYUV2BGR(int width, int height, const unsigned char* yuv, cv::Mat& resmat, bool inRGBorder, bool withAlpha);
 
     friend class HighguiAndroidCameraActivity;
 };
@@ -179,8 +189,8 @@ CvCapture_Android::CvCapture_Android(int cameraId)
     m_height              = 0;
     m_activity            = 0;
     m_isOpened            = false;
-    m_frameYUV420i        = 0;
-    m_frameYUV420inext    = 0;
+    m_frameYUV420        = 0;
+    m_frameYUV420next    = 0;
     m_hasGray             = false;
     m_hasColor            = false;
     m_dataState           = CVCAPTURE_ANDROID_STATE_NO_FRAME;
@@ -188,6 +198,7 @@ CvCapture_Android::CvCapture_Android(int cameraId)
     m_shouldAutoGrab      = false;
     m_framesGrabbed       = 0;
     m_CameraParamsChanged = false;
+    m_frameFormat         = noformat;
 
     //try connect to camera
     m_activity = new HighguiAndroidCameraActivity(this);
@@ -223,10 +234,10 @@ CvCapture_Android::~CvCapture_Android()
 
 	pthread_mutex_lock(&m_nextFrameMutex);
 
-	unsigned char *tmp1=m_frameYUV420i;
-	unsigned char *tmp2=m_frameYUV420inext;
-        m_frameYUV420i = 0;
-        m_frameYUV420inext = 0;
+        unsigned char *tmp1=m_frameYUV420;
+        unsigned char *tmp2=m_frameYUV420next;
+        m_frameYUV420 = 0;
+        m_frameYUV420next = 0;
         delete tmp1;
         delete tmp2;
 
@@ -255,6 +266,8 @@ double CvCapture_Android::getProperty( int propIdx )
 
     case CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING:
 	return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_SUPPORTED_PREVIEW_SIZES_STRING);
+    case CV_CAP_PROP_PREVIEW_FORMAT:
+        return (double)m_activity->getProperty(ANDROID_CAMERA_PROPERTY_PREVIEW_FORMAT_STRING);
     default:
         CV_Error( CV_StsOutOfRange, "Failed attempt to GET unsupported camera property." );
         break;
@@ -318,9 +331,9 @@ bool CvCapture_Android::grabFrame()
     if (m_dataState == CVCAPTURE_ANDROID_STATE_HAS_NEW_FRAME_UNGRABBED) {
             //LOGD("CvCapture_Android::grabFrame: get new frame");
 	    //swap current and new frames
-	    unsigned char* tmp = m_frameYUV420i;
-	    m_frameYUV420i = m_frameYUV420inext;
-	    m_frameYUV420inext = tmp;
+            unsigned char* tmp = m_frameYUV420;
+            m_frameYUV420 = m_frameYUV420next;
+            m_frameYUV420next = tmp;
 
 	    //discard cached frames
 	    m_hasGray = false;
@@ -348,27 +361,39 @@ IplImage* CvCapture_Android::retrieveFrame( int outputType )
 {
     IplImage* image = NULL;
 
-    unsigned char *current_frameYUV420i=m_frameYUV420i;
+    unsigned char *current_frameYUV420=m_frameYUV420;
     //Attention! all the operations in this function below should occupy less time than the period between two frames from camera
-    if (NULL != current_frameYUV420i)
+    if (NULL != current_frameYUV420)
     {
+        if (m_frameFormat == noformat)
+        {
+            union {double prop; const char* name;} u;
+            u.prop = getProperty(CV_CAP_PROP_PREVIEW_FORMAT);
+            if (0 == strcmp(u.name, "yuv420sp"))
+                m_frameFormat = yuv420sp;
+            else if (0 == strcmp(u.name, "yuv420i"))
+                m_frameFormat = yuv420i;
+            else
+                m_frameFormat = yuvUnknown;
+        }
+
         switch(outputType)
         {
         case CV_CAP_ANDROID_GREY_FRAME:
             if (!m_hasGray)
-                if (!(m_hasGray = convertYUV420i2Grey(m_width, m_height, current_frameYUV420i, m_frameGray.mat)))
+                if (!(m_hasGray = convertYUV2Grey(m_width, m_height, current_frameYUV420, m_frameGray.mat)))
                     return NULL;
             image = m_frameGray.getIplImagePtr();
             break;
         case CV_CAP_ANDROID_COLOR_FRAME_BGR: case CV_CAP_ANDROID_COLOR_FRAME_RGB:
             if (!m_hasColor)
-                if (!(m_hasColor = convertYUV420i2BGR(m_width, m_height, current_frameYUV420i, m_frameColor.mat, outputType == CV_CAP_ANDROID_COLOR_FRAME_RGB, false)))
+                if (!(m_hasColor = convertYUV2BGR(m_width, m_height, current_frameYUV420, m_frameColor.mat, outputType == CV_CAP_ANDROID_COLOR_FRAME_RGB, false)))
                     return NULL;
             image = m_frameColor.getIplImagePtr();
             break;
         case CV_CAP_ANDROID_COLOR_FRAME_BGRA: case CV_CAP_ANDROID_COLOR_FRAME_RGBA:
             if (!m_hasColor)
-                if (!(m_hasColor = convertYUV420i2BGR(m_width, m_height, current_frameYUV420i, m_frameColor.mat, outputType == CV_CAP_ANDROID_COLOR_FRAME_RGBA, true)))
+                if (!(m_hasColor = convertYUV2BGR(m_width, m_height, current_frameYUV420, m_frameColor.mat, outputType == CV_CAP_ANDROID_COLOR_FRAME_RGBA, true)))
                     return NULL;
             image = m_frameColor.getIplImagePtr();
             break;
@@ -391,22 +416,22 @@ void CvCapture_Android::setFrame(const void* buffer, int bufferSize)
 
     if ( expectedSize != bufferSize)
     {
-        LOGE("ERROR reading YUV420i buffer: width=%d, height=%d, size=%d, receivedSize=%d", width, height, expectedSize, bufferSize);
+        LOGE("ERROR reading YUV buffer: width=%d, height=%d, size=%d, receivedSize=%d", width, height, expectedSize, bufferSize);
         return;
     }
 
     //allocate memory if needed
-    prepareCacheForYUV420i(width, height);
+    prepareCacheForYUV(width, height);
 
     //copy data
-    memcpy(m_frameYUV420inext, buffer, bufferSize);
+    memcpy(m_frameYUV420next, buffer, bufferSize);
     //LOGD("CvCapture_Android::setFrame -- memcpy is done");
 
 #if 0 //moved this part of code into grabFrame
     //swap current and new frames
-    unsigned char* tmp = m_frameYUV420i;
-    m_frameYUV420i = m_frameYUV420inext;
-    m_frameYUV420inext = tmp;
+    unsigned char* tmp = m_frameYUV420;
+    m_frameYUV420 = m_frameYUV420next;
+    m_frameYUV420next = tmp;
 
     //discard cached frames
     m_hasGray = false;
@@ -418,30 +443,31 @@ void CvCapture_Android::setFrame(const void* buffer, int bufferSize)
 }
 
 //Attention: this method should be called inside pthread_mutex_lock(m_nextFrameMutex) only
-void CvCapture_Android::prepareCacheForYUV420i(int width, int height)
+void CvCapture_Android::prepareCacheForYUV(int width, int height)
 {
     if (width != m_width || height != m_height)
     {
-	LOGD("CvCapture_Android::prepareCacheForYUV420i: Changing size of buffers: from width=%d height=%d to width=%d height=%d", m_width, m_height, width, height);
+        LOGD("CvCapture_Android::prepareCacheForYUV: Changing size of buffers: from width=%d height=%d to width=%d height=%d", m_width, m_height, width, height);
         m_width = width;
         m_height = height;
-        unsigned char *tmp = m_frameYUV420inext;
-        m_frameYUV420inext = new unsigned char [width * height * 3 / 2];
+        unsigned char *tmp = m_frameYUV420next;
+        m_frameYUV420next = new unsigned char [width * height * 3 / 2];
 	if (tmp != NULL) {
 		delete[] tmp;
 	}
 
-        tmp = m_frameYUV420i;
-        m_frameYUV420i = new unsigned char [width * height * 3 / 2];
+        tmp = m_frameYUV420;
+        m_frameYUV420 = new unsigned char [width * height * 3 / 2];
 	if (tmp != NULL) {
 		delete[] tmp;
 	}
     }
 }
 
-bool CvCapture_Android::convertYUV420i2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat)
+bool CvCapture_Android::convertYUV2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat)
 {
     if (yuv == 0) return false;
+    if (m_frameFormat != yuv420sp && m_frameFormat != yuv420i) return false;
 #define ALWAYS_COPY_GRAY 0
 #if ALWAYS_COPY_GRAY
     resmat.create(height, width, CV_8UC1);
@@ -453,14 +479,19 @@ bool CvCapture_Android::convertYUV420i2Grey(int width, int height, const unsigne
     return !resmat.empty();
 }
 
-bool CvCapture_Android::convertYUV420i2BGR(int width, int height, const unsigned char* yuv, cv::Mat& resmat, bool inRGBorder, bool withAlpha)
+bool CvCapture_Android::convertYUV2BGR(int width, int height, const unsigned char* yuv, cv::Mat& resmat, bool inRGBorder, bool withAlpha)
 {
     if (yuv == 0) return false;
+    if (m_frameFormat != yuv420sp && m_frameFormat != yuv420i) return false;
+
     CV_Assert(width % 2 == 0 && height % 2 == 0);
 
     cv::Mat src(height*3/2, width, CV_8UC1, (void*)yuv);
 
-    cv::cvtColor(src, resmat, inRGBorder ? CV_YUV420i2RGB : CV_YUV420i2BGR, withAlpha ? 4 : 3);
+    if (m_frameFormat == yuv420sp)
+        cv::cvtColor(src, resmat, inRGBorder ? CV_YUV420sp2RGB : CV_YUV420sp2BGR, withAlpha ? 4 : 3);
+    else if (m_frameFormat == yuv420i)
+        cv::cvtColor(src, resmat, inRGBorder ? CV_YUV420i2RGB : CV_YUV420i2BGR, withAlpha ? 4 : 3);
 
     return !resmat.empty();
 }
diff --git a/modules/highgui/src/cap_dshow.cpp b/modules/highgui/src/cap_dshow.cpp
index ed1b35725d..39d8c057ce 100644
--- a/modules/highgui/src/cap_dshow.cpp
+++ b/modules/highgui/src/cap_dshow.cpp
@@ -673,7 +673,7 @@ public:
 
 
 	//------------------------------------------------
-    STDMETHODIMP QueryInterface(REFIID riid, void **ppvObject){
+    STDMETHODIMP QueryInterface(REFIID, void **ppvObject){
         *ppvObject = static_cast<ISampleGrabberCB*>(this);
         return S_OK;
     }
@@ -681,7 +681,7 @@ public:
     
     //This method is meant to have less overhead
 	//------------------------------------------------
-    STDMETHODIMP SampleCB(double Time, IMediaSample *pSample){
+    STDMETHODIMP SampleCB(double, IMediaSample *pSample){
     	if(WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0) return S_OK;
  
     	HRESULT hr = pSample->GetPointer(&ptrBuffer);  
@@ -705,7 +705,7 @@ public:
     
     
     //This method is meant to have more overhead
-    STDMETHODIMP BufferCB(double Time, BYTE *pBuffer, long BufferLen){
+    STDMETHODIMP BufferCB(double, BYTE *, long){
     	return E_NOTIMPL;
     }
 
@@ -847,7 +847,7 @@ void videoDevice::NukeDownstream(IBaseFilter *pBF){
 // ---------------------------------------------------------------------- 
 
 void videoDevice::destroyGraph(){
-	HRESULT hr = NULL;
+	HRESULT hr = NOERROR;
  	//int FuncRetval=0;
  	//int NumFilters=0;
 
@@ -865,7 +865,8 @@ void videoDevice::destroyGraph(){
 		IBaseFilter * pFilter = NULL;
 		if (pEnum->Next(1, &pFilter, &cFetched) == S_OK)
 		{
-			FILTER_INFO FilterInfo={0};
+			FILTER_INFO FilterInfo;
+            memset(&FilterInfo, 0, sizeof(FilterInfo));
 			hr = pFilter->QueryFilterInfo(&FilterInfo);
 			FilterInfo.pGraph->Release();
 
@@ -875,7 +876,7 @@ void videoDevice::destroyGraph(){
 						
 			while( FilterInfo.achName[count] != 0x00 ) 
 			{
-				buffer[count] = FilterInfo.achName[count];
+				buffer[count] = (char)FilterInfo.achName[count];
 				count++;
 			}
 			
@@ -914,7 +915,7 @@ videoDevice::~videoDevice(){
 		return;
 	}
 		
-	HRESULT HR = NULL;
+	HRESULT HR = NOERROR;
 	
 	//Stop the callback and free it
     if( (sgCallback) && (pGrabber) )
@@ -1345,7 +1346,7 @@ int videoInput::listDevices(bool silent){
 					int count = 0;
 					int maxLen = sizeof(deviceNames[0])/sizeof(deviceNames[0][0]) - 2;
 					while( varName.bstrVal[count] != 0x00 && count < maxLen) {
-						deviceNames[deviceCounter][count] = varName.bstrVal[count];
+						deviceNames[deviceCounter][count] = (char)varName.bstrVal[count];
 						count++;
 					}
 					deviceNames[deviceCounter][count] = 0;
@@ -1664,7 +1665,7 @@ bool videoInput::setVideoSettingFilterPct(int deviceID, long Property, float pct
 		float halfStep 	= (float)stepAmnt * 0.5f;
 		if( mod < halfStep ) rasterValue -= mod;
 		else rasterValue += stepAmnt - mod;	
-		printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue); 
+		printf("RASTER - pctValue is %f - value is %ld - step is %ld - mod is %ld - rasterValue is %ld\n", pctValue, value, stepAmnt, mod, rasterValue); 
 	}
 		
 	return setVideoSettingFilter(deviceID, Property, rasterValue, Flags, false);
@@ -1751,7 +1752,7 @@ bool videoInput::setVideoSettingCameraPct(int deviceID, long Property, float pct
 		float halfStep 	= (float)stepAmnt * 0.5f;
 		if( mod < halfStep ) rasterValue -= mod;
 		else rasterValue += stepAmnt - mod;	
-		printf("RASTER - pctValue is %f - value is %i - step is %i - mod is %i - rasterValue is %i\n", pctValue, value, stepAmnt, mod, rasterValue); 
+		printf("RASTER - pctValue is %f - value is %ld - step is %ld - mod is %ld - rasterValue is %ld\n", pctValue, value, stepAmnt, mod, rasterValue); 
 	}
 	
 	return setVideoSettingCamera(deviceID, Property, rasterValue, Flags, false);
@@ -1866,7 +1867,7 @@ bool videoInput::restartDevice(int id){
 		int nReconnect	= VDList[id]->nFramesForReconnect;
 		bool bReconnect = VDList[id]->autoReconnect;
 
-		unsigned long avgFrameTime = VDList[id]->requestedFrameTime;
+		long avgFrameTime = VDList[id]->requestedFrameTime;
 	
 		stopDevice(id);
 
@@ -1914,7 +1915,7 @@ videoInput::~videoInput(){
 // ---------------------------------------------------------------------- 
 
 bool videoInput::comInit(){
-	HRESULT hr = NULL;
+	HRESULT hr = NOERROR;
 
 	//no need for us to start com more than once
 	if(comInitCount == 0 ){
@@ -2273,7 +2274,7 @@ static bool setSizeAndSubtype(videoDevice * VD, int attemptWidth, int attemptHei
 
 int videoInput::start(int deviceID, videoDevice *VD){
 
-	HRESULT hr 			= NULL;
+	HRESULT hr 			= NOERROR;
 	VD->myID 			= deviceID;
 	VD->setupStarted	= true;
     CAPTURE_MODE   		= PIN_CATEGORY_CAPTURE; //Don't worry - it ends up being preview (which is faster)
diff --git a/modules/highgui/src/cap_ffmpeg_impl.hpp b/modules/highgui/src/cap_ffmpeg_impl.hpp
index ccb8f13fbc..14ed8b750b 100644
--- a/modules/highgui/src/cap_ffmpeg_impl.hpp
+++ b/modules/highgui/src/cap_ffmpeg_impl.hpp
@@ -135,6 +135,52 @@ extern "C" {
 #define PIX_FMT_RGBA32 PIX_FMT_RGB32
 #endif
 
+#define CALC_FFMPEG_VERSION(a,b,c) ( a<<16 | b<<8 | c )
+
+#if defined WIN32 || defined _WIN32
+    #include <windows.h>
+#elif defined __linux__ || defined __APPLE__
+    #include <unistd.h>
+    #include <stdio.h>
+    #include <sys/types.h> 
+    #include <sys/sysctl.h>
+#endif
+
+int get_number_of_cpus(void)
+{
+#if defined WIN32 || defined _WIN32
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo( &sysinfo );
+    
+    return (int)sysinfo.dwNumberOfProcessors;
+#elif defined __linux__
+    return (int)sysconf( _SC_NPROCESSORS_ONLN );
+#elif defined __APPLE__
+    int numCPU=0;
+    int mib[4];
+    size_t len = sizeof(numCPU); 
+    
+    /* set the mib for hw.ncpu */
+    mib[0] = CTL_HW;
+    mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
+    
+    /* get the number of CPUs from the system */
+    sysctl(mib, 2, &numCPU, &len, NULL, 0);
+    
+    if( numCPU < 1 ) 
+    {
+        mib[1] = HW_NCPU;
+        sysctl( mib, 2, &numCPU, &len, NULL, 0 );
+        
+        if( numCPU < 1 )
+            numCPU = 1;
+    }
+
+    return (int)numCPU;
+#else
+    return 1;
+#endif
+}
 
 
 char * FOURCC2str( int fourcc )
@@ -444,6 +490,9 @@ bool CvCapture_FFMPEG::reopen()
 #else
     AVCodecContext *enc = &ic->streams[video_stream]->codec;
 #endif
+
+    avcodec_thread_init(enc, get_number_of_cpus());
+
     AVCodec *codec = avcodec_find_decoder(enc->codec_id);
     avcodec_open(enc, codec);
     video_st = ic->streams[video_stream];
@@ -489,7 +538,13 @@ bool CvCapture_FFMPEG::open( const char* _filename )
         AVCodecContext *enc = &ic->streams[i]->codec;
 #endif
 
-        if( CODEC_TYPE_VIDEO == enc->codec_type && video_stream < 0) {
+        avcodec_thread_init(enc, get_number_of_cpus());
+
+        #if LIBAVFORMAT_BUILD < CALC_FFMPEG_VERSION(53, 4, 0)
+            #define AVMEDIA_TYPE_VIDEO CODEC_TYPE_VIDEO
+        #endif
+        
+        if( AVMEDIA_TYPE_VIDEO == enc->codec_type && video_stream < 0) {
             AVCodec *codec = avcodec_find_decoder(enc->codec_id);
             if (!codec ||
             avcodec_open(enc, codec) < 0)
@@ -576,14 +631,18 @@ bool CvCapture_FFMPEG::grabFrame()
 		        continue;
     		}
 
-#if LIBAVFORMAT_BUILD > 4628
-        avcodec_decode_video(video_st->codec,
-                             picture, &got_picture,
-                             packet.data, packet.size);
+#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 4, 0)
+			avcodec_decode_video2(video_st->codec, picture, &got_picture, &packet); 
 #else
-        avcodec_decode_video(&video_st->codec,
-                             picture, &got_picture,
-                             packet.data, packet.size);
+	#if LIBAVFORMAT_BUILD > 4628
+			avcodec_decode_video(video_st->codec,
+								 picture, &got_picture,
+								 packet.data, packet.size);
+	#else
+			avcodec_decode_video(&video_st->codec,
+								 picture, &got_picture,
+								 packet.data, packet.size);
+	#endif
 #endif
 
         if (got_picture) {
@@ -703,11 +762,10 @@ double CvCapture_FFMPEG::getProperty( int property_id )
 #endif
     break;
     }
+	
     return 0;
 }
 
-
-
 // this is a VERY slow fallback function, ONLY used if ffmpeg's av_seek_frame delivers no correct result!
 bool CvCapture_FFMPEG::slowSeek( int framenumber )
 {
@@ -739,7 +797,7 @@ bool CvCapture_FFMPEG::setProperty( int property_id, double value )
             int64_t    timestamp  = ic->streams[video_stream]->first_dts;
             AVRational time_base  = ic->streams[video_stream]->time_base;
             AVRational frame_base = ic->streams[video_stream]->r_frame_rate;
-            double     timeScale  = (time_base.den / (double)time_base.num) / (frame_base.num / frame_base.den);
+            double     timeScale  = (time_base.den / (double)time_base.num) / (frame_base.num / (double)frame_base.den);
             switch( property_id )
             {
             case CV_FFMPEG_CAP_PROP_POS_FRAMES:
@@ -787,7 +845,6 @@ bool CvCapture_FFMPEG::setProperty( int property_id, double value )
             picture_pts=(int64_t)value;
         }
         break;
-
     default:
         return false;
     }
@@ -824,6 +881,38 @@ struct CvVideoWriter_FFMPEG
 
 static const char * icvFFMPEGErrStr(int err)
 {
+#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 4, 0)
+    switch(err) {
+ 		case AVERROR_BSF_NOT_FOUND:
+ 			return "Bitstream filter not found";
+ 		case AVERROR_DECODER_NOT_FOUND:
+ 			return "Decoder not found";
+ 		case AVERROR_DEMUXER_NOT_FOUND:
+ 			return "Demuxer not found";
+ 		case AVERROR_ENCODER_NOT_FOUND:
+ 			return "Encoder not found";
+ 		case AVERROR_EOF:
+ 			return "End of file";
+ 		case AVERROR_EXIT:
+ 			return "Immediate exit was requested; the called function should not be restarted";
+ 		case AVERROR_FILTER_NOT_FOUND:
+ 			return "Filter not found";
+ 		case AVERROR_INVALIDDATA:
+ 			return "Invalid data found when processing input";
+ 		case AVERROR_MUXER_NOT_FOUND:
+ 			return "Muxer not found";
+ 		case AVERROR_OPTION_NOT_FOUND:
+ 			return "Option not found";
+ 		case AVERROR_PATCHWELCOME:
+ 			return "Not yet implemented in FFmpeg, patches welcome";
+ 		case AVERROR_PROTOCOL_NOT_FOUND:
+ 			return "Protocol not found";
+ 		case AVERROR_STREAM_NOT_FOUND:
+ 			return "Stream not found";
+ 		default:
+ 			break;
+ 	}
+#else
     switch(err) {
     case AVERROR_NUMEXPECTED:
 		return "Incorrect filename syntax";
@@ -838,7 +927,9 @@ static const char * icvFFMPEGErrStr(int err)
     default:
 		break;
     }
-  	return "Unspecified error";
+#endif
+
+ 	return "Unspecified error";
 }
 
 /* function internal to FFMPEG (libavformat/riff.c) to lookup codec id by fourcc tag*/
@@ -918,7 +1009,7 @@ static AVStream *icv_add_video_stream_FFMPEG(AVFormatContext *oc,
 #endif
 
 #if LIBAVFORMAT_BUILD > 4621
-	c->codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
+	c->codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
 #else
 	c->codec_id = oc->oformat->video_codec;
 #endif
@@ -930,7 +1021,7 @@ static AVStream *icv_add_video_stream_FFMPEG(AVFormatContext *oc,
     //if(codec_tag) c->codec_tag=codec_tag;
 	codec = avcodec_find_encoder(c->codec_id);
 
-	c->codec_type = CODEC_TYPE_VIDEO;
+	c->codec_type = AVMEDIA_TYPE_VIDEO;
 
 	/* put sample parameters */
 	c->bit_rate = bitrate;
@@ -1015,7 +1106,11 @@ int icv_av_write_frame_FFMPEG( AVFormatContext * oc, AVStream * video_st, uint8_
         AVPacket pkt;
         av_init_packet(&pkt);
 
-        pkt.flags |= PKT_FLAG_KEY;
+		#ifndef PKT_FLAG_KEY
+			#define PKT_FLAG_KEY AV_PKT_FLAG_KEY
+		#endif
+		
+        pkt.flags |= PKT_FLAG_KEY; 
         pkt.stream_index= video_st->index;
         pkt.data= (uint8_t *)picture;
         pkt.size= sizeof(AVPicture);
@@ -1237,7 +1332,13 @@ bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc,
 	av_register_all ();
 
 	/* auto detect the output format from the name and fourcc code. */
+
+#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 4, 0)
+	fmt = av_guess_format(NULL, filename, NULL);
+#else
 	fmt = guess_format(NULL, filename, NULL);
+#endif
+	
 	if (!fmt)
         return false;
 
@@ -1260,7 +1361,11 @@ bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc,
 #endif
 
     // alloc memory for context
+#if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(53, 4, 0)
+	oc = avformat_alloc_context();
+#else
 	oc = av_alloc_format_context();
+#endif
 	assert (oc);
 
 	/* set file name */
diff --git a/modules/highgui/src/cap_libv4l.cpp b/modules/highgui/src/cap_libv4l.cpp
index 4e05d79d1c..ce7507279c 100644
--- a/modules/highgui/src/cap_libv4l.cpp
+++ b/modules/highgui/src/cap_libv4l.cpp
@@ -497,7 +497,7 @@ static void v4l2_scan_controls_enumerate_menu(CvCaptureCAM_V4L* capture)
     if (0 == xioctl (capture->deviceHandle, VIDIOC_QUERYMENU,
                      &capture->querymenu))
     {
-      printf (" %s\n", capture->querymenu.name);
+      //printf (" %s\n", capture->querymenu.name);
     } else {
         perror ("VIDIOC_QUERYMENU");
     }
diff --git a/modules/highgui/src/cap_openni.cpp b/modules/highgui/src/cap_openni.cpp
index 25dceb10ac..74bc74afcc 100644
--- a/modules/highgui/src/cap_openni.cpp
+++ b/modules/highgui/src/cap_openni.cpp
@@ -118,7 +118,7 @@ protected:
     IplImage* retrieveBGRImage();
     IplImage* retrieveGrayImage();
 
-    void readCamerasParams();
+    bool readCamerasParams();
 
     double getDepthGeneratorProperty(int propIdx);
     bool setDepthGeneratorProperty(int propIdx, double propVal);
@@ -177,6 +177,7 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
     depthOutputMode.nFPS = imageOutputMode.nFPS = 30;
 
     m_isOpened = false;
+    bool isContextInitialized = false;
 
     // Initialize and configure the context.
     if( context.Init() == XN_STATUS_OK )
@@ -185,7 +186,11 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
         xn::NodeInfoList devicesList;
         status = context.EnumerateProductionTrees( XN_NODE_TYPE_DEVICE, NULL, devicesList, 0 );
         if( status != XN_STATUS_OK )
-            CV_Error(CV_StsError, ("Failed to enumerate production trees: " + std::string(xnGetStatusString(status))).c_str() );
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to enumerate production trees: "
+                      << std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
 
         // Chose device according to index
         xn::NodeInfoList::Iterator it = devicesList.Begin();
@@ -194,7 +199,11 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
         xn::NodeInfo deviceNode = *it;
         status = context.CreateProductionTree( deviceNode );
         if( status != XN_STATUS_OK )
-            CV_Error(CV_StsError, ("Failed to create production tree: " + std::string(xnGetStatusString(status))).c_str() );
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create production tree: "
+                      << std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
 
 #ifdef HACK_WITH_XML
         // Write configuration to the temporary file.
@@ -206,39 +215,65 @@ CvCapture_OpenNI::CvCapture_OpenNI( int index )
         outfile.close();
 
         status = context.RunXmlScriptFromFile( xmlFilename.c_str() );
+        if( status != XN_STATUS_OK )
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to run xml script: "
+                      << std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
 
         // Remove temporary configuration file.
         remove( xmlFilename.c_str() );
 #else
         status = context.RunXmlScript( XMLConfig.c_str() );
 #endif
-        m_isOpened = ( status == XN_STATUS_OK );
+        isContextInitialized = ( status == XN_STATUS_OK );
     }
 
-    if( m_isOpened )
+    if( isContextInitialized )
     {
         // Associate generators with context.
         status = depthGenerator.Create( context );
-        if( status != XN_STATUS_OK )
-            CV_Error(CV_StsError, ("Failed to create depth generator: " + std::string(xnGetStatusString(status))).c_str() );
+        if( status != XN_STATUS_OK )\
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create depth generator: "
+                      << std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
+
         imageGenerator.Create( context );
         if( status != XN_STATUS_OK )
-            CV_Error(CV_StsError, ("Failed to create image generator: " + std::string(xnGetStatusString(status))).c_str() );
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to create image generator: "
+                      <<  std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
 
         // Set map output mode.
         CV_Assert( depthGenerator.SetMapOutputMode( depthOutputMode ) == XN_STATUS_OK ); // xn::DepthGenerator supports VGA only! (Jan 2011)
         CV_Assert( imageGenerator.SetMapOutputMode( imageOutputMode ) == XN_STATUS_OK );
-        CV_Assert( depthGenerator.GetAlternativeViewPointCap().SetViewPoint( imageGenerator ) == XN_STATUS_OK );
 
         //  Start generating data.
         status = context.StartGeneratingAll();
         if( status != XN_STATUS_OK )
-            CV_Error(CV_StsError, ("Failed to start generating OpenNI data: " + std::string(xnGetStatusString(status))).c_str() );
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Failed to start generating OpenNI data: "
+                      << std::string(xnGetStatusString(status)) << std::endl;
+            return;
+        }
 
-        readCamerasParams();
+        if( !readCamerasParams() )
+        {
+            std::cerr << "CvCapture_OpenNI::CvCapture_OpenNI : Could not read cameras parameters" << std::endl;
+            return;
+        }
 
         outputMaps.resize( outputTypesCount );
+
+        m_isOpened = true;
     }
+
+    setProperty(CV_CAP_PROP_OPENNI_REGISTRATION, 1.0);
 }
 
 CvCapture_OpenNI::~CvCapture_OpenNI()
@@ -247,11 +282,14 @@ CvCapture_OpenNI::~CvCapture_OpenNI()
     context.Shutdown();
 }
 
-void CvCapture_OpenNI::readCamerasParams()
+bool CvCapture_OpenNI::readCamerasParams()
 {
     XnDouble pixelSize = 0;
     if( depthGenerator.GetRealProperty( "ZPPS", pixelSize ) != XN_STATUS_OK )
-        CV_Error( CV_StsError, "Could not read pixel size!" );
+    {
+        std::cerr << "CvCapture_OpenNI::readCamerasParams : Could not read pixel size!" << std::endl;
+        return false;
+    }
 
     // pixel size @ VGA = pixel size @ SXGA x 2
     pixelSize *= 2.0; // in mm
@@ -259,10 +297,16 @@ void CvCapture_OpenNI::readCamerasParams()
     // focal length of IR camera in pixels for VGA resolution
     XnUInt64 zeroPlanDistance; // in mm
     if( depthGenerator.GetIntProperty( "ZPD", zeroPlanDistance ) != XN_STATUS_OK )
-        CV_Error( CV_StsError, "Could not read virtual plane distance!" );
+    {
+        std::cerr << "CvCapture_OpenNI::readCamerasParams : Could not read virtual plane distance!" << std::endl;
+        return false;
+    }
 
     if( depthGenerator.GetRealProperty( "LDDIS", baseline ) != XN_STATUS_OK )
-        CV_Error( CV_StsError, "Could not read base line!" );
+    {
+        std::cerr << "CvCapture_OpenNI::readCamerasParams : Could not read base line!" << std::endl;
+        return false;
+    }
 
     // baseline from cm -> mm
     baseline *= 10;
@@ -271,10 +315,18 @@ void CvCapture_OpenNI::readCamerasParams()
     depthFocalLength_VGA = (XnUInt64)((double)zeroPlanDistance / (double)pixelSize);
 
     if( depthGenerator.GetIntProperty( "ShadowValue", shadowValue ) != XN_STATUS_OK )
-        CV_Error( CV_StsError, "Could not read property \"ShadowValue\"!" );
+    {
+        std::cerr << "CvCapture_OpenNI::readCamerasParams : Could not read property \"ShadowValue\"!" << std::endl;
+        return false;
+    }
 
     if( depthGenerator.GetIntProperty("NoSampleValue", noSampleValue ) != XN_STATUS_OK )
-        CV_Error( CV_StsError, "Could not read property \"NoSampleValue\"!" );
+    {
+        std::cerr << "CvCapture_OpenNI::readCamerasParams : Could not read property \"NoSampleValue\"!" <<std::endl;
+        return false;
+    }
+
+    return true;
 }
 
 double CvCapture_OpenNI::getProperty( int propIdx )
@@ -351,6 +403,8 @@ double CvCapture_OpenNI::getDepthGeneratorProperty( int propIdx )
     case CV_CAP_PROP_OPENNI_FOCAL_LENGTH :
         res = depthFocalLength_VGA;
         break;
+    case CV_CAP_PROP_OPENNI_REGISTRATION :
+        res = depthGenerator.GetAlternativeViewPointCap().IsViewPointAs(imageGenerator) ? 1.0 : 0.0;
     default :
         CV_Error( CV_StsBadArg, "Depth generator does not support such parameter for getting.\n");
     }
@@ -360,30 +414,48 @@ double CvCapture_OpenNI::getDepthGeneratorProperty( int propIdx )
 
 bool CvCapture_OpenNI::setDepthGeneratorProperty( int propIdx, double propValue )
 {
+    bool res = false;
+
     CV_Assert( depthGenerator.IsValid() );
-    switch(propIdx)
+
+    switch( propIdx )
     {
-        case CV_CAP_PROP_OPENNI_REGISTRATION_ON:
+        case CV_CAP_PROP_OPENNI_REGISTRATION:
             {
-                CV_Assert( imageGenerator.IsValid() );
-                if (!depthGenerator.GetAlternativeViewPointCap ().IsViewPointAs (imageGenerator))
+                if( propValue != 0.0 ) // "on"
                 {
-                    if (depthGenerator.GetAlternativeViewPointCap ().IsViewPointSupported (imageGenerator))
+                    CV_Assert( imageGenerator.IsValid() );
+                    if( !depthGenerator.GetAlternativeViewPointCap().IsViewPointAs(imageGenerator) )
                     {
-                      XnStatus status = depthGenerator.GetAlternativeViewPointCap().SetViewPoint (imageGenerator);
-                      if (status != XN_STATUS_OK)
-                         CV_Error( CV_StsError, std::string("turning registration on failed. Reason: ") + xnGetStatusString (status));
+                        if( depthGenerator.GetAlternativeViewPointCap().IsViewPointSupported(imageGenerator) )
+                        {
+                            XnStatus status = depthGenerator.GetAlternativeViewPointCap().SetViewPoint(imageGenerator);
+                            if( status != XN_STATUS_OK )
+                                std::cerr << "CvCapture_OpenNI::setDepthGeneratorProperty : " << xnGetStatusString(status) << std::endl;
+                            else
+                                res = true;
+                        }
+                        else
+                           std::cerr << "CvCapture_OpenNI::setDepthGeneratorProperty : Unsupported viewpoint." << std::endl;
                     }
                     else
-                       CV_Error( CV_StsError, "turning registration on failed. Reason: unsupported viewpoint");
+                        res = true;
+                }
+                else // "off"
+                {
+                    XnStatus status = depthGenerator.GetAlternativeViewPointCap().ResetViewPoint();
+                    if( status != XN_STATUS_OK )
+                        std::cerr << "CvCapture_OpenNI::setDepthGeneratorProperty : " << xnGetStatusString(status) << std::endl;
+                    else
+                        res = true;
                 }
             }
-            return true;
             break;
         default:
-            CV_Error( CV_StsBadArg, "Depth generator does not support such parameter for setting.\n");
+            CV_Error( CV_StsBadArg, "Unsupported depth generator property.\n");
     }
-    return false;
+
+    return res;
 }
 
 double CvCapture_OpenNI::getImageGeneratorProperty( int propIdx )
@@ -414,10 +486,13 @@ bool CvCapture_OpenNI::setImageGeneratorProperty( int propIdx, double propValue
     bool res = false;
 
     CV_Assert( imageGenerator.IsValid() );
-    XnMapOutputMode newImageOutputMode = imageOutputMode;
+
     switch( propIdx )
     {
     case CV_CAP_PROP_OPENNI_OUTPUT_MODE :
+    {
+        XnMapOutputMode newImageOutputMode = imageOutputMode;
+
         switch( cvRound(propValue) )
         {
         case CV_CAP_OPENNI_VGA_30HZ :
@@ -433,16 +508,19 @@ bool CvCapture_OpenNI::setImageGeneratorProperty( int propIdx, double propValue
         default :
             CV_Error( CV_StsBadArg, "Unsupported image generator output mode.\n");
         }
+
+        XnStatus status = imageGenerator.SetMapOutputMode( newImageOutputMode );
+        if( status != XN_STATUS_OK )
+            std::cerr << "CvCapture_OpenNI::setImageGeneratorProperty : " << xnGetStatusString(status) << std::endl;
+        else
+        {
+            imageOutputMode = newImageOutputMode;
+            res = true;
+        }
         break;
-
-   default:
-        CV_Error( CV_StsBadArg, "Image generator does not support such parameter for setting.\n");
     }
-
-    if( imageGenerator.SetMapOutputMode( newImageOutputMode ) == XN_STATUS_OK )
-    {
-        imageOutputMode = newImageOutputMode;
-        res = true;
+    default:
+        CV_Error( CV_StsBadArg, "Unsupported image generator property.\n");
     }
 
     return res;
diff --git a/modules/highgui/src/cap_qtkit.mm b/modules/highgui/src/cap_qtkit.mm
index 17737c0364..3cbcb751f2 100644
--- a/modules/highgui/src/cap_qtkit.mm
+++ b/modules/highgui/src/cap_qtkit.mm
@@ -733,7 +733,7 @@ IplImage* CvCaptureFile::retrieveFramePixelBuffer() {
 		image->height = height; 
 		image->nChannels = 4; 
 		image->depth = IPL_DEPTH_8U; 
-		image->widthStep = width*4; 
+		image->widthStep = rowBytes; 
 		image->imageData = imagedata; 
 		image->imageSize = currSize; 
 		
@@ -746,7 +746,7 @@ IplImage* CvCaptureFile::retrieveFramePixelBuffer() {
 		bgr_image->height = height; 
 		bgr_image->nChannels = 3; 
 		bgr_image->depth = IPL_DEPTH_8U; 
-		bgr_image->widthStep = width*4; 
+		bgr_image->widthStep = rowBytes; 
 		bgr_image->imageData = bgr_imagedata; 
 		bgr_image->imageSize = currSize; 
 		
diff --git a/modules/highgui/src/cap_ximea.cpp b/modules/highgui/src/cap_ximea.cpp
new file mode 100755
index 0000000000..a80341433a
--- /dev/null
+++ b/modules/highgui/src/cap_ximea.cpp
@@ -0,0 +1,253 @@
+
+#include "precomp.hpp"
+
+#include "xiApi.h"
+#include "xiExt.h"
+
+/**********************************************************************************/
+
+class CvCaptureCAM_XIMEA : public CvCapture
+{
+public:
+    CvCaptureCAM_XIMEA() { init(); }
+    virtual ~CvCaptureCAM_XIMEA() { close(); }
+
+    virtual bool open( int index );
+    virtual void close();
+    virtual double getProperty(int);
+    virtual bool setProperty(int, double);
+    virtual bool grabFrame();
+    virtual IplImage* retrieveFrame(int);
+	virtual int getCaptureDomain() { return CV_CAP_XIAPI; } // Return the type of the capture object: CV_CAP_VFW, etc...
+
+protected:
+	void init();
+	void errMsg(char* msg, int errNum);
+    IplImage* frame;
+
+	HANDLE    hmv;
+	DWORD     numDevices;
+	XI_IMG    image;
+	int       width;
+	int       height;
+	int       format;
+	int       timeout;
+};
+
+/**********************************************************************************/
+
+CvCapture* cvCreateCameraCapture_XIMEA( int index )
+{
+     CvCaptureCAM_XIMEA* capture = new CvCaptureCAM_XIMEA;
+
+    if( capture->open( index ))
+        return capture;
+
+	delete capture;
+    return 0;
+}
+
+/**********************************************************************************/
+// Enumerate connected devices
+void CvCaptureCAM_XIMEA::init()
+{
+	xiGetNumberDevices( &numDevices);
+	hmv = NULL;
+}
+
+
+/**********************************************************************************/
+// Initialize camera input
+bool CvCaptureCAM_XIMEA::open( int wIndex )
+{
+	int mvret = XI_OK;
+
+	if(numDevices == 0)
+		return false;
+	
+	if((mvret = xiOpenDevice( wIndex, &hmv)) != XI_OK)
+  {
+		errMsg("Open XI_DEVICE failed", mvret);
+		return false;
+	}
+
+	// always use auto exposure/gain
+	xiSetParamInt( hmv, XI_PRM_AEAG, 1);
+
+	// always use auto white ballance
+	xiSetParamInt( hmv, XI_PRM_AUTO_WB, 1);
+
+	xiGetParamInt( hmv, XI_PRM_WIDTH, &width);
+	xiGetParamInt( hmv, XI_PRM_HEIGHT, &height);
+	
+	// default image format RGB24
+	xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, XI_RGB24);
+	format = XI_RGB24;
+	// allocate frame buffer for RGB24 image
+	frame = cvCreateImage(cvSize( width, height), IPL_DEPTH_8U, 3); 
+
+	//default capture timeout 10s
+	timeout = 10000;
+
+	return true;
+}
+
+/**********************************************************************************/
+
+void CvCaptureCAM_XIMEA::close()
+{
+	xiCloseDevice(hmv);
+	hmv = NULL;
+}
+
+/**********************************************************************************/
+
+bool CvCaptureCAM_XIMEA::grabFrame()
+{
+	int mvret = XI_OK;
+	image.size = sizeof(XI_IMG);
+	if((mvret = xiGetImage( hmv, timeout, &image)) != XI_OK)
+  {
+		errMsg("Error during GetImage", mvret);
+		return false;
+	}
+    return true;
+}
+
+/**********************************************************************************/
+
+IplImage* CvCaptureCAM_XIMEA::retrieveFrame(int)
+{
+	// update cvImage after format has changed
+	if( image.width != width || image.height != height || image.frm != format)
+	{
+		cvReleaseImage(&frame);
+		switch( image.frm)
+		{
+		case XI_MONO8  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 1); break;
+		case XI_MONO16 : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_16U, 1); break; 
+		case XI_RGB24  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 3); break;
+		case XI_RGB32  : frame = cvCreateImage(cvSize( image.width, image.height), IPL_DEPTH_8U, 4); break;
+		}
+		// update global image format
+		format = image.frm;	
+		width = image.width;
+		height = image.height;
+	}
+
+	// copy pixel data
+	switch( image.frm)
+	{
+	case XI_MONO8  : memcpy( frame->imageData, image.bp, image.width*image.height); break;
+	case XI_MONO16 : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(WORD)); break;
+	case XI_RGB24  : memcpy( frame->imageData, image.bp, image.width*image.height*3); break;
+	case XI_RGB32  : memcpy( frame->imageData, image.bp, image.width*image.height*sizeof(DWORD)); break;
+	}
+	return frame;
+}
+
+/**********************************************************************************/
+
+double CvCaptureCAM_XIMEA::getProperty( int property_id )
+{
+	if(hmv == NULL)
+		return 0;
+
+	int ival = 0;
+	float fval = 0;
+
+	switch( property_id )
+  {
+	// OCV parameters
+  case CV_CAP_PROP_POS_FRAMES   : return (double) image.nframe;
+  case CV_CAP_PROP_FRAME_WIDTH  : xiGetParamInt( hmv, XI_PRM_WIDTH, &ival); return ival;
+  case CV_CAP_PROP_FRAME_HEIGHT : xiGetParamInt( hmv, XI_PRM_HEIGHT, &ival); return ival;
+  case CV_CAP_PROP_FPS          : xiGetParamFloat( hmv, XI_PRM_FRAMERATE, &fval); return fval;
+  case CV_CAP_PROP_GAIN         : xiGetParamFloat( hmv, XI_PRM_GAIN, &fval); return fval;
+  case CV_CAP_PROP_EXPOSURE     : xiGetParamInt( hmv, XI_PRM_EXPOSURE, &ival); return ival;
+
+	// XIMEA camera properties
+	case CV_CAP_PROP_XI_DOWNSAMPLING  : xiGetParamInt( hmv, XI_PRM_DOWNSAMPLING, &ival); return ival;
+	case CV_CAP_PROP_XI_DATA_FORMAT   : xiGetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, &ival); return ival;
+	case CV_CAP_PROP_XI_OFFSET_X      : xiGetParamInt( hmv, XI_PRM_OFFSET_X, &ival); return ival;
+	case CV_CAP_PROP_XI_OFFSET_Y      : xiGetParamInt( hmv, XI_PRM_OFFSET_Y, &ival); return ival;
+	case CV_CAP_PROP_XI_TRG_SOURCE    : xiGetParamInt( hmv, XI_PRM_TRG_SOURCE, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPI_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_MODE      : xiGetParamInt( hmv, XI_PRM_GPI_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_GPI_LEVEL     : xiGetParamInt( hmv, XI_PRM_GPI_LEVEL, &ival); return ival;
+	case CV_CAP_PROP_XI_GPO_SELECTOR  : xiGetParamInt( hmv, XI_PRM_GPO_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_GPO_MODE      : xiGetParamInt( hmv, XI_PRM_GPO_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_LED_SELECTOR  : xiGetParamInt( hmv, XI_PRM_LED_SELECTOR, &ival); return ival;
+	case CV_CAP_PROP_XI_LED_MODE      : xiGetParamInt( hmv, XI_PRM_LED_MODE, &ival); return ival;
+	case CV_CAP_PROP_XI_AUTO_WB       : xiGetParamInt( hmv, XI_PRM_AUTO_WB, &ival); return ival;
+	case CV_CAP_PROP_XI_AEAG          : xiGetParamInt( hmv, XI_PRM_AEAG, &ival); return ival;
+	case CV_CAP_PROP_XI_EXP_PRIORITY  : xiGetParamFloat( hmv, XI_PRM_EXP_PRIORITY, &fval); return fval;
+	case CV_CAP_PROP_XI_AE_MAX_LIMIT  : xiGetParamInt( hmv, XI_PRM_EXP_PRIORITY, &ival); return ival;
+	case CV_CAP_PROP_XI_AG_MAX_LIMIT  : xiGetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, &fval); return fval;
+	case CV_CAP_PROP_XI_AEAG_LEVEL    : xiGetParamInt( hmv, XI_PRM_AEAG_LEVEL, &ival); return ival;
+	case CV_CAP_PROP_XI_TIMEOUT       : return timeout;
+  }
+	return 0;
+}
+
+/**********************************************************************************/
+
+bool CvCaptureCAM_XIMEA::setProperty( int property_id, double value )
+{ 
+	int ival = (int) value; 
+	float fval = (float) value;
+	
+	int mvret = XI_OK;
+	
+	switch(property_id)
+	{
+	// OCV parameters
+    case CV_CAP_PROP_FRAME_WIDTH  : mvret = xiSetParamInt( hmv, XI_PRM_WIDTH, ival); break;
+    case CV_CAP_PROP_FRAME_HEIGHT : mvret = xiSetParamInt( hmv, XI_PRM_HEIGHT, ival); break;
+    case CV_CAP_PROP_FPS          : mvret = xiSetParamFloat( hmv, XI_PRM_FRAMERATE, fval); break;
+	case CV_CAP_PROP_GAIN         : mvret = xiSetParamFloat( hmv, XI_PRM_GAIN, fval); break;
+	case CV_CAP_PROP_EXPOSURE     : mvret = xiSetParamInt( hmv, XI_PRM_EXPOSURE, ival); break;
+	// XIMEA camera properties
+	case CV_CAP_PROP_XI_DOWNSAMPLING  :  mvret = xiSetParamInt( hmv, XI_PRM_DOWNSAMPLING, ival); break;
+	case CV_CAP_PROP_XI_DATA_FORMAT   : mvret = xiSetParamInt( hmv, XI_PRM_IMAGE_DATA_FORMAT, ival); break;
+	case CV_CAP_PROP_XI_OFFSET_X      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_X, ival); break;
+	case CV_CAP_PROP_XI_OFFSET_Y      : mvret = xiSetParamInt( hmv, XI_PRM_OFFSET_Y, ival); break;
+	case CV_CAP_PROP_XI_TRG_SOURCE    : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, ival); break;
+	case CV_CAP_PROP_XI_GPI_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPI_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_TRG_SOFTWARE  : mvret = xiSetParamInt( hmv, XI_PRM_TRG_SOURCE, 1); break;		
+	case CV_CAP_PROP_XI_GPI_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPI_MODE, ival); break; 
+	case CV_CAP_PROP_XI_GPI_LEVEL     : mvret = xiSetParamInt( hmv, XI_PRM_GPI_LEVEL, ival); break;
+	case CV_CAP_PROP_XI_GPO_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_GPO_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_GPO_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_GPO_MODE, ival); break; 
+	case CV_CAP_PROP_XI_LED_SELECTOR  : mvret = xiSetParamInt( hmv, XI_PRM_LED_SELECTOR, ival); break;
+	case CV_CAP_PROP_XI_LED_MODE      : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break; 
+	case CV_CAP_PROP_XI_AUTO_WB       : mvret = xiSetParamInt( hmv, XI_PRM_AUTO_WB, ival); break;
+	case CV_CAP_PROP_XI_MANUAL_WB     : mvret = xiSetParamInt( hmv, XI_PRM_LED_MODE, ival); break;
+	case CV_CAP_PROP_XI_AEAG          : mvret = xiSetParamInt( hmv, XI_PRM_AEAG, ival); break;
+	case CV_CAP_PROP_XI_EXP_PRIORITY  : mvret = xiSetParamFloat( hmv, XI_PRM_EXP_PRIORITY, fval); break; 
+	case CV_CAP_PROP_XI_AE_MAX_LIMIT  : mvret = xiSetParamInt( hmv, XI_PRM_EXP_PRIORITY, ival); break;
+	case CV_CAP_PROP_XI_AG_MAX_LIMIT  : mvret = xiSetParamFloat( hmv, XI_PRM_AG_MAX_LIMIT, fval); break;
+	case CV_CAP_PROP_XI_AEAG_LEVEL    : mvret = xiSetParamInt( hmv, XI_PRM_AEAG_LEVEL, ival); break; 
+	case CV_CAP_PROP_XI_TIMEOUT       : timeout = ival; break;
+	}
+
+	if(mvret != XI_OK)
+  {
+		errMsg("Set parameter error", mvret);
+		return false;
+	} 
+  else
+		return true; 
+		
+}
+
+/**********************************************************************************/
+
+void CvCaptureCAM_XIMEA::errMsg(char* msg, int errNum)
+{
+	char buf[512];
+	sprintf( buf, "%s : %d\n", msg, errNum);
+	OutputDebugString(buf);
+}
+
+/**********************************************************************************/
\ No newline at end of file
diff --git a/modules/highgui/src/grfmt_png.cpp b/modules/highgui/src/grfmt_png.cpp
index 1cb37e4586..d0e2680384 100644
--- a/modules/highgui/src/grfmt_png.cpp
+++ b/modules/highgui/src/grfmt_png.cpp
@@ -56,6 +56,7 @@
 #else
 #include <png.h>
 #endif
+#include <zlib.h>
 #include "grfmt_png.hpp"
 
 namespace cv
@@ -166,9 +167,18 @@ bool  PngDecoder::readHeader()
 
                     if( bit_depth <= 8 || bit_depth == 16 )
                     {
-                        m_type = color_type == PNG_COLOR_TYPE_RGB ||
-                             color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
-                             color_type == PNG_COLOR_TYPE_PALETTE ? CV_8UC3 : CV_8UC1;
+                        switch(color_type) 
+                        {
+                           case PNG_COLOR_TYPE_RGB:
+                           case PNG_COLOR_TYPE_PALETTE:
+                               m_type = CV_8UC3;
+                               break;
+                          case PNG_COLOR_TYPE_RGB_ALPHA:
+                               m_type = CV_8UC4;
+                               break;
+                          default:
+                               m_type = CV_8UC1;
+                        }
                         if( bit_depth == 16 )
                             m_type = CV_MAKETYPE(CV_16U, CV_MAT_CN(m_type));
                         result = true;
@@ -209,15 +219,18 @@ bool  PngDecoder::readData( Mat& img )
             else if( !isBigEndian() )
                 png_set_swap( png_ptr );
 
-            /* observation: png_read_image() writes 400 bytes beyond
-             * end of data when reading a 400x118 color png
-             * "mpplus_sand.png".  OpenCV crashes even with demo
-             * programs.  Looking at the loaded image I'd say we get 4
-             * bytes per pixel instead of 3 bytes per pixel.  Test
-             * indicate that it is a good idea to always ask for
-             * stripping alpha..  18.11.2004 Axel Walthelm
-             */
-            png_set_strip_alpha( png_ptr );
+            if(img.channels() < 4) 
+            {
+                /* observation: png_read_image() writes 400 bytes beyond
+                 * end of data when reading a 400x118 color png
+                 * "mpplus_sand.png".  OpenCV crashes even with demo
+                 * programs.  Looking at the loaded image I'd say we get 4
+                 * bytes per pixel instead of 3 bytes per pixel.  Test
+                 * indicate that it is a good idea to always ask for
+                 * stripping alpha..  18.11.2004 Axel Walthelm
+                 */
+                 png_set_strip_alpha( png_ptr );
+            }
 
             if( m_color_type == PNG_COLOR_TYPE_PALETTE )
                 png_set_palette_to_rgb( png_ptr );
diff --git a/modules/highgui/src/grfmt_tiff.cpp b/modules/highgui/src/grfmt_tiff.cpp
index 1db9624f89..686acf02e5 100644
--- a/modules/highgui/src/grfmt_tiff.cpp
+++ b/modules/highgui/src/grfmt_tiff.cpp
@@ -185,7 +185,7 @@ bool  TiffDecoder::readData( Mat& img )
         TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp );
         TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn );
         const int bitsPerByte = 8;
-        int dst_bpp = img.elemSize1() * bitsPerByte;
+        int dst_bpp = (int)(img.elemSize1() * bitsPerByte);
 
         if(dst_bpp == 8)
         {
@@ -427,7 +427,7 @@ bool  TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
     
     const int bitsPerByte = 8;
     size_t fileStep = (width * channels * bitsPerChannel) / bitsPerByte;
-    int rowsPerStrip = (1 << 13)/fileStep;
+    int rowsPerStrip = (int)((1 << 13)/fileStep);
 
     if( rowsPerStrip < 1 )
         rowsPerStrip = 1;
diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp
index bbdc1d7340..b4980bff25 100644
--- a/modules/highgui/src/precomp.hpp
+++ b/modules/highgui/src/precomp.hpp
@@ -133,6 +133,7 @@ CvVideoWriter* cvCreateVideoWriter_VFW( const char* filename, int fourcc,
 CvCapture* cvCreateCameraCapture_DShow( int index );
 CvCapture* cvCreateCameraCapture_OpenNI( int index );
 CvCapture* cvCreateCameraCapture_Android( int index );
+CvCapture* cvCreateCameraCapture_XIMEA( int index );
 
 CVAPI(int) cvHaveImageReader(const char* filename);
 CVAPI(int) cvHaveImageWriter(const char* filename);
diff --git a/modules/highgui/test/test_ffmpeg.cpp b/modules/highgui/test/test_ffmpeg.cpp
index 510d6bb753..22f9b678ed 100644
--- a/modules/highgui/test/test_ffmpeg.cpp
+++ b/modules/highgui/test/test_ffmpeg.cpp
@@ -124,10 +124,10 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
 				const int img_c = 480;
 				Size frame_s = Size(img_c, img_r);
 
-				for (size_t k = 1; k <= 5; ++k)
+				for (int k = 1; k <= 5; ++k)
 				{
-					for (size_t ext = 0; ext < 4; ++ext) // 0 - png, 1 - bmp, 2 - pgm, 3 - tiff
-					for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
+					for (int ext = 0; ext < 4; ++ext) // 0 - png, 1 - bmp, 2 - pgm, 3 - tiff
+					for (int num_channels = 1; num_channels <= 3; num_channels+=2)
 					{
 						ts->printf(ts->LOG, "image type depth:%d   channels:%d   ext: %s\n", CV_8U, num_channels, ext_from_int(ext).c_str());
 						Mat img(img_r * k, img_c * k, CV_MAKETYPE(CV_8U, num_channels), Scalar::all(0));
@@ -151,7 +151,7 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
 						}
 					}
 
-					for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
+					for (int num_channels = 1; num_channels <= 3; num_channels+=2)
 					{
 						// jpeg
 						ts->printf(ts->LOG, "image type depth:%d   channels:%d   ext: %s\n", CV_8U, num_channels, ".jpg");
@@ -178,7 +178,7 @@ class CV_FFmpegWriteSequenceImageTest : public cvtest::BaseTest
 						}
 					}
 
-					for (size_t num_channels = 1; num_channels <= 3; num_channels+=2)
+					for (int num_channels = 1; num_channels <= 3; num_channels+=2)
 					{
 						// tiff
 						ts->printf(ts->LOG, "image type depth:%d   channels:%d   ext: %s\n", CV_16U, num_channels, ".tiff");
diff --git a/modules/imgproc/doc/feature_detection.rst b/modules/imgproc/doc/feature_detection.rst
index 58bfe67bca..4b8b251215 100644
--- a/modules/imgproc/doc/feature_detection.rst
+++ b/modules/imgproc/doc/feature_detection.rst
@@ -222,7 +222,7 @@ Determines strong corners on an image.
 
 .. ocv:pyfunction:: cv2.goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]) -> corners
 
-.. ocv:cfunction:: void cvGoodFeaturesToTrack( const CvArr* image, CvArr* eigImage, CvArr* tempImage CvPoint2D32f* corners, int* cornerCount, double qualityLevel, double minDistance, const CvArr* mask=NULL, int blockSize=3, int useHarris=0, double k=0.04 )
+.. ocv:cfunction:: void cvGoodFeaturesToTrack( const CvArr* image, CvArr* eigImage, CvArr* tempImage, CvPoint2D32f* corners, int* cornerCount, double qualityLevel, double minDistance, const CvArr* mask=NULL, int blockSize=3, int useHarris=0, double k=0.04 )
 
 .. ocv:pyoldfunction:: cv.GoodFeaturesToTrack(image, eigImage, tempImage, cornerCount, qualityLevel, minDistance, mask=None, blockSize=3, useHarris=0, k=0.04)-> corners
 
@@ -285,12 +285,16 @@ Finds circles in a grayscale image using the Hough transform.
 
 .. ocv:function:: void HoughCircles( InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )
 
+.. ocv:cfunction:: CvSeq* cvHoughCircles( CvArr* image, CvMemStorage* circleStorage, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )
+
 .. ocv:pyfunction:: cv2.HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) -> circles
 
     :param image: 8-bit, single-channel, grayscale input image.
 
     :param circles: Output vector of found circles. Each vector is encoded as a 3-element floating-point vector  :math:`(x, y, radius)` .
     
+    :param circleStorage: In C function this is a memory storage that will contain the output sequence of found circles.
+    
     :param method: Detection method to use. Currently, the only implemented method is  ``CV_HOUGH_GRADIENT`` , which is basically  *21HT* , described in  [Yuen90]_.
 
     :param dp: Inverse ratio of the accumulator resolution to the image resolution. For example, if  ``dp=1`` , the accumulator has the same resolution as the input image. If  ``dp=2`` , the accumulator has half as big width and height.
diff --git a/modules/imgproc/doc/filtering.rst b/modules/imgproc/doc/filtering.rst
index 6ce4e3cb7c..ec50c6d14a 100644
--- a/modules/imgproc/doc/filtering.rst
+++ b/modules/imgproc/doc/filtering.rst
@@ -55,13 +55,12 @@ where
 
 .. seealso::
 
-    :ocv:func:`BaseRowFilter`,
-    :ocv:func:`BaseFilter`,
-    :ocv:func:`FilterEngine`,
-    :ocv:func:`getColumnSumFilter`,
-    :ocv:func:`getLinearColumnFilter`,
-    :ocv:func:`getMorphologyColumnFilter`
-
+   :ocv:func:`BaseRowFilter`,
+   :ocv:func:`BaseFilter`,
+   :ocv:func:`FilterEngine`,
+   :ocv:func:`getColumnSumFilter`,
+   :ocv:func:`getLinearColumnFilter`,
+   :ocv:func:`getMorphologyColumnFilter`
 
 
 BaseFilter
@@ -360,15 +359,15 @@ Explore the data types. As it was mentioned in the
 
 .. seealso::
 
-    :ocv:func:`BaseColumnFilter`,
-    :ocv:func:`BaseFilter`,
-    :ocv:func:`BaseRowFilter`,
-    :ocv:func:`createBoxFilter`,
-    :ocv:func:`createDerivFilter`,
-    :ocv:func:`createGaussianFilter`,
-    :ocv:func:`createLinearFilter`,
-    :ocv:func:`createMorphologyFilter`,
-    :ocv:func:`createSeparableLinearFilter`
+   :ocv:func:`BaseColumnFilter`,
+   :ocv:func:`BaseFilter`,
+   :ocv:func:`BaseRowFilter`,
+   :ocv:func:`createBoxFilter`,
+   :ocv:func:`createDerivFilter`,
+   :ocv:func:`createGaussianFilter`,
+   :ocv:func:`createLinearFilter`,
+   :ocv:func:`createMorphologyFilter`,
+   :ocv:func:`createSeparableLinearFilter`
 
 
 
@@ -431,11 +430,10 @@ The call ``blur(src, dst, ksize, anchor, borderType)`` is equivalent to ``boxFil
 
 .. seealso::
 
-    :ocv:func:`boxFilter`,
-    :ocv:func:`bilateralFilter`,
-    :ocv:func:`GaussianBlur`,
-    :ocv:func:`medianBlur` 
-
+   :ocv:func:`boxFilter`,
+   :ocv:func:`bilateralFilter`,
+   :ocv:func:`GaussianBlur`,
+   :ocv:func:`medianBlur` 
 
 
 borderInterpolate
@@ -580,6 +578,7 @@ The function supports the mode when ``src`` is already in the middle of ``dst``
 
 
 .. seealso::
+
     :ocv:func:`borderInterpolate`
 
 
@@ -970,12 +969,12 @@ The function convolves the source image with the specified Gaussian kernel. In-p
 
 .. seealso::
 
-    :ocv:func:`sepFilter2D`,
-    :ocv:func:`filter2D`,
-    :ocv:func:`blur`,
-    :ocv:func:`boxFilter`,
-    :ocv:func:`bilateralFilter`,
-    :ocv:func:`medianBlur`
+   :ocv:func:`sepFilter2D`,
+   :ocv:func:`filter2D`,
+   :ocv:func:`blur`,
+   :ocv:func:`boxFilter`,
+   :ocv:func:`bilateralFilter`,
+   :ocv:func:`medianBlur`
 
 
 getDerivKernels
@@ -1041,11 +1040,11 @@ Two of such generated kernels can be passed to
 
 .. seealso::
 
-    :ocv:func:`sepFilter2D`,
-    :ocv:func:`createSeparableLinearFilter`,
-    :ocv:func:`getDerivKernels`,
-    :ocv:func:`getStructuringElement`,
-    :ocv:func:`GaussianBlur` 
+   :ocv:func:`sepFilter2D`,
+   :ocv:func:`createSeparableLinearFilter`,
+   :ocv:func:`getDerivKernels`,
+   :ocv:func:`getStructuringElement`,
+   :ocv:func:`GaussianBlur` 
 
 
 
@@ -1300,7 +1299,7 @@ The function performs the downsampling step of the Gaussian pyramid construction
 
 .. math::
 
-    \frac{1}{16} \begin{bmatrix} 1 & 4 & 6 & 4 & 1  \\ 4 & 16 & 24 & 16 & 4  \\ 6 & 24 & 36 & 24 & 6  \\ 4 & 16 & 24 & 16 & 4  \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}
+    \frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1  \\ 4 & 16 & 24 & 16 & 4  \\ 6 & 24 & 36 & 24 & 6  \\ 4 & 16 & 24 & 16 & 4  \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}
 
 Then, it downsamples the image by rejecting even rows and columns.
 
@@ -1333,7 +1332,7 @@ pyrMeanShiftFiltering
 ---------------------
 Performs initial step of meanshift segmentation of an image.
 
-.. ocv:function: void pyrMeanShiftFiltering( InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) )
+.. ocv:function:: void pyrMeanShiftFiltering( InputArray src, OutputArray dst, double sp, double sr, int maxLevel=1, TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) )
 
 .. ocv:pyfunction:: cv2.pyrMeanShiftFiltering(src, sp, sr[, dst[, maxLevel[, termcrit]]]) -> dst
 
@@ -1406,12 +1405,12 @@ The function applies a separable linear filter to the image. That is, first, eve
 
 .. seealso::
 
-    :ocv:func:`createSeparableLinearFilter`,
-    :ocv:func:`filter2D`,
-    :ocv:func:`Sobel`,
-    :ocv:func:`GaussianBlur`,
-    :ocv:func:`boxFilter`,
-    :ocv:func:`blur` 
+   :ocv:func:`createSeparableLinearFilter`,
+   :ocv:func:`filter2D`,
+   :ocv:func:`Sobel`,
+   :ocv:func:`GaussianBlur`,
+   :ocv:func:`boxFilter`,
+   :ocv:func:`blur` 
 
 
 Smooth
@@ -1538,7 +1537,7 @@ The second case corresponds to a kernel of:
 .. seealso::
 
     :ocv:func:`Scharr`,
-    :ocv:func:`Lapacian`,
+    :ocv:func:`Laplacian`,
     :ocv:func:`sepFilter2D`,
     :ocv:func:`filter2D`,
     :ocv:func:`GaussianBlur`
diff --git a/modules/imgproc/doc/geometric_transformations.rst b/modules/imgproc/doc/geometric_transformations.rst
index 2706dca3e7..ad92359772 100644
--- a/modules/imgproc/doc/geometric_transformations.rst
+++ b/modules/imgproc/doc/geometric_transformations.rst
@@ -5,6 +5,7 @@ Geometric Image Transformations
 The functions in this section perform various geometrical transformations of 2D images. They do not change the image content but deform the pixel grid and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel
 :math:`(x, y)` of the destination image, the functions compute coordinates of the corresponding "donor" pixel in the source image and copy the pixel value:
 
+The functions in this section perform various geometrical transformations of 2D images. They do not change the image content but deform the pixel grid and map this deformed grid to the destination image. In fact, to avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel :math:`(x, y)` of the destination image, the functions compute    coordinates of the corresponding "donor" pixel in the source image and copy the pixel value:
 .. math::
 
     \texttt{dst} (x,y)= \texttt{src} (f_x(x,y), f_y(x,y))
@@ -485,7 +486,7 @@ Applies a perspective transformation to an image.
 
     :param dst: Destination image that has the size  ``dsize``  and the same type as  ``src`` .
     
-	:param M: :math:`3\times 3`  transformation matrix.
+    :param M: :math:`3\times 3`  transformation matrix.
 
     :param dsize: Size of the destination image.
 
@@ -696,4 +697,4 @@ where ``undistort()`` is an approximate iterative algorithm that estimates the n
 
 The function can be used for both a stereo camera head or a monocular camera (when R is empty).
 
- 
\ No newline at end of file
+ 
diff --git a/modules/imgproc/doc/histograms.rst b/modules/imgproc/doc/histograms.rst
index 12aa2dc3cf..98fb76ff14 100644
--- a/modules/imgproc/doc/histograms.rst
+++ b/modules/imgproc/doc/histograms.rst
@@ -124,9 +124,9 @@ Calculates the back projection of a histogram.
     :param hist: Input histogram that can be dense or sparse.
 
     :param backProject: Destination back projection aray that is a single-channel array of the same size and depth as  ``arrays[0]`` .
-	
+    
     :param ranges: Array of arrays of the histogram bin boundaries in each dimension. See  :ocv:func:`calcHist` .
-	
+    
     :param scale: Optional scale factor for the output back projection.
 
     :param uniform: Flag indicating whether the histogram is uniform or not (see above).
@@ -146,7 +146,7 @@ This is an approximate algorithm of the
 :ocv:func:`CAMShift` color object tracker.
 
 .. seealso:: :ocv:func:`calcHist`
-
+.. _compareHist:
 
 compareHist
 -----------
@@ -164,16 +164,16 @@ Compares two histograms.
     :param H1: First compared histogram.
 
     :param H2: Second compared histogram of the same size as  ``H1`` .
-	
+    
     :param method: Comparison method that could be one of the following:
 
-            * **CV_COMP_CORREL** 	Correlation
+            * **CV_COMP_CORREL**     Correlation
 
-            * **CV_COMP_CHISQR** 	Chi-Square
+            * **CV_COMP_CHISQR**     Chi-Square
 
-            * **CV_COMP_INTERSECT** 	Intersection
+            * **CV_COMP_INTERSECT**     Intersection
 
-            * **CV_COMP_BHATTACHARYYA** 	Bhattacharyya distance
+            * **CV_COMP_BHATTACHARYYA**     Bhattacharyya distance
 
 The functions ``compareHist`` compare two dense or two sparse histograms using the specified method:
 
@@ -367,6 +367,7 @@ Copies a histogram.
     
 The function makes a copy of the histogram. If the second histogram pointer ``*dst`` is NULL, a new histogram of the same size as  ``src`` is created. Otherwise, both histograms must have equal types and sizes. Then the function copies the bin values of the source histogram to the destination histogram and sets the same bin value ranges as in ``src``.
 
+.. _createhist:
 
 CreateHist
 ----------
@@ -587,4 +588,4 @@ between the calculated minimum and maximum distances are incremented
 
 .. [RubnerSept98] Y. Rubner. C. Tomasi, L.J. Guibas. *The Earth Mover’s Distance as a Metric for Image Retrieval*. Technical Report STAN-CS-TN-98-86, Department of Computer Science, Stanford University, September 1998.
 
-.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html
\ No newline at end of file
+.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html
diff --git a/modules/imgproc/doc/miscellaneous_transformations.rst b/modules/imgproc/doc/miscellaneous_transformations.rst
index b9507000f4..6bc9767e6c 100644
--- a/modules/imgproc/doc/miscellaneous_transformations.rst
+++ b/modules/imgproc/doc/miscellaneous_transformations.rst
@@ -24,7 +24,7 @@ Applies an adaptive threshold to an array.
     :param adaptiveMethod: Adaptive thresholding algorithm to use, ``ADAPTIVE_THRESH_MEAN_C``  or  ``ADAPTIVE_THRESH_GAUSSIAN_C`` . See the details below.
 
     :param thresholdType: Thresholding type that must be either  ``THRESH_BINARY``  or  ``THRESH_BINARY_INV`` .
-	
+    
     :param blockSize: Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.
 
     :param C: Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.
@@ -607,9 +607,9 @@ Restores the selected region in an image using the region neighborhood.
 
     :param flags: Inpainting method that could be one of the following:
 
-            * **INPAINT_NS** 	Navier-Stokes based method.
+            * **INPAINT_NS**     Navier-Stokes based method.
 
-            * **INPAINT_TELEA** 	Method by Alexandru Telea  [Telea04]_.
+            * **INPAINT_TELEA**     Method by Alexandru Telea  [Telea04]_.
 
 The function reconstructs the selected image area from the pixel near the area boundary. The function may be used to remove dust and scratches from a scanned photo, or to remove undesirable objects from still images or video. See
 http://en.wikipedia.org/wiki/Inpainting
@@ -758,34 +758,24 @@ Performs a marker-based image segmentation using the watershed algrorithm.
 
 .. ocv:function:: void watershed( InputArray image, InputOutputArray markers )
 
+.. ocv:cfunction:: void cvWatershed( const CvArr* image, CvArr* markers )
+
 .. ocv:pyfunction:: cv2.watershed(image, markers) -> None
 
     :param image: Input 8-bit 3-channel image.
 
     :param markers: Input/output 32-bit single-channel image (map) of markers. It should have the same size as  ``image`` .
 
-The function implements one of the variants
-of watershed, non-parametric marker-based segmentation algorithm,
-described in [Meyer92]_. Before passing the image to the
-function, you have to roughly outline the desired regions in the image ``markers`` with positive (
-:math:`>0` ) indices. So, every region is
-represented as one or more connected components with the pixel values
-1, 2, 3, and so on. Such markers can be retrieved from a binary mask
-using
-:ocv:func:`findContours` and
-:ocv:func:`drawContours` (see the ``watershed.cpp`` demo).
-The markers are "seeds" of the future image
-regions. All the other pixels in ``markers`` , whose relation to the
-outlined regions is not known and should be defined by the algorithm,
-should be set to 0's. In the function output, each pixel in
-markers is set to a value of the "seed" components or to -1 at
-boundaries between the regions.
+The function implements one of the variants of watershed, non-parametric marker-based segmentation algorithm, described in [Meyer92]_.
 
-.. note:: Every two neighbor connected components are not necessarily separated by a watershed boundary (-1's pixels); for example, when such tangent components exist in the initial marker image. Visual demonstration and usage example of the function can be found in the OpenCV samples directory (see the ``watershed.cpp`` demo).
+Before passing the image to the function, you have to roughly outline the desired regions in the image ``markers`` with positive (``>0``) indices. So, every region is represented as one or more connected components with the pixel values 1, 2, 3, and so on. Such markers can be retrieved from a binary mask using :ocv:func:`findContours` and :ocv:func:`drawContours` (see the ``watershed.cpp`` demo). The markers are "seeds" of the future image regions. All the other pixels in ``markers`` , whose relation to the outlined regions is not known and should be defined by the algorithm, should be set to 0's. In the function output, each pixel in markers is set to a value of the "seed" components or to -1 at boundaries between the regions.
+
+Visual demonstration and usage example of the function can be found in the OpenCV samples directory (see the ``watershed.cpp`` demo).
+
+.. note:: Any two neighbor connected components are not necessarily separated by a watershed boundary (-1's pixels); for example, they can touch each other in the initial marker image passed to the function.
 
 .. seealso:: :ocv:func:`findContours`
 
-
 grabCut
 -------
 Runs the GrabCut algorithm.
@@ -816,11 +806,11 @@ Runs the GrabCut algorithm.
     
     :param mode: Operation mode that could be one of the following:
 
-        * **GC_INIT_WITH_RECT** 	The function initializes the state and the mask using the provided rectangle. After that it runs  ``iterCount``  iterations of the algorithm.
+        * **GC_INIT_WITH_RECT**     The function initializes the state and the mask using the provided rectangle. After that it runs  ``iterCount``  iterations of the algorithm.
 
-        * **GC_INIT_WITH_MASK** 	The function initializes the state using the provided mask. Note that  ``GC_INIT_WITH_RECT``  and  ``GC_INIT_WITH_MASK``  can be combined. Then, all the pixels outside of the ROI are automatically initialized with  ``GC_BGD`` .
+        * **GC_INIT_WITH_MASK**     The function initializes the state using the provided mask. Note that  ``GC_INIT_WITH_RECT``  and  ``GC_INIT_WITH_MASK``  can be combined. Then, all the pixels outside of the ROI are automatically initialized with  ``GC_BGD`` .
 
-        * **GC_EVAL** 	The value means that the algorithm should just resume.
+        * **GC_EVAL**     The value means that the algorithm should just resume.
 
 The function implements the `GrabCut image segmentation algorithm <http://en.wikipedia.org/wiki/GrabCut>`_.
 See the sample ``grabcut.cpp`` to learn how to use the function.
diff --git a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst
index 4c84e1cc2e..b61315dfd0 100644
--- a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst
+++ b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst
@@ -9,7 +9,7 @@ Adds an image to the accumulator.
 
 .. ocv:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulate(src, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulate(src, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvAcc( const CvArr* src, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.Acc(src, dst, mask=None)-> None
@@ -44,7 +44,7 @@ Adds the square of a source image to the accumulator.
 
 .. ocv:function:: void accumulateSquare( InputArray src, InputOutputArray dst,  InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateSquare(src, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateSquare(src, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvSquareAcc( const CvArr* src, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.SquareAcc(src, dst, mask=None)-> None
@@ -77,7 +77,7 @@ Adds the per-element product of two input images to the accumulator.
 
 .. ocv:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateProduct(src1, src2, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateProduct(src1, src2, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvMultiplyAcc( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.MultiplyAcc(src1, src2, dst, mask=None)-> None
@@ -85,7 +85,7 @@ Adds the per-element product of two input images to the accumulator.
     :param src1: First input image, 1- or 3-channel, 8-bit or 32-bit floating point.
 
     :param src2: Second input image of the same type and the same size as  ``src1`` .
-	
+    
     :param dst: Accumulator with the same number of channels as input images, 32-bit or 64-bit floating-point.
 
     :param mask: Optional operation mask.
@@ -112,7 +112,7 @@ Updates a running average.
 
 .. ocv:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateWeighted(src, dst, alpha[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateWeighted(src, dst, alpha[, mask]) -> None
 
 .. ocv:cfunction:: void cvRunningAvg( const CvArr* src, CvArr* dst, double alpha, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.RunningAvg(src, dst, alpha, mask=None)-> None
diff --git a/modules/imgproc/doc/object_detection.rst b/modules/imgproc/doc/object_detection.rst
index 4faec8c96f..3ee6bf34c0 100644
--- a/modules/imgproc/doc/object_detection.rst
+++ b/modules/imgproc/doc/object_detection.rst
@@ -19,7 +19,7 @@ Compares a template against overlapped image regions.
     :param templ: Searched template. It must be not greater than the source image and have the same data type.
 
     :param result: Map of comparison results. It must be single-channel 32-bit floating-point. If  ``image``  is  :math:`W \times H`  and ``templ``  is  :math:`w \times h` , then  ``result``  is  :math:`(W-w+1) \times (H-h+1)` .
-	
+    
     :param method: Parameter specifying the comparison method (see below).
 
 The function slides through ``image`` , compares the
diff --git a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst
index 718c95b6da..247617d879 100644
--- a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst
+++ b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst
@@ -31,15 +31,6 @@ The function computes moments, up to the 3rd order, of a vector shape or a raste
         Moments( const CvMoments& moments );
         operator CvMoments() const;
 
-        // spatial moments
-        double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
-        // central moments
-        double  mu20, mu11, mu02, mu30, mu21, mu12, mu03;
-        // central normalized moments
-        double  nu20, nu11, nu02, nu30, nu21, nu12, nu03;
-    };
-
-
 In case of a raster image, the spatial moments :math:`\texttt{Moments::m}_{ji}` are computed as:
 
 .. math::
@@ -174,7 +165,7 @@ Draws contours outlines or filled contours.
     :param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
 
     :param color: Color of the contours.
-	
+    
     :param thickness: Thickness of lines the contours are drawn with. If it is negative (for example,  ``thickness=CV_FILLED`` ), the contour interiors are
         drawn.
 
diff --git a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
index a843889558..bd79955fb6 100644
--- a/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
+++ b/modules/imgproc/include/opencv2/imgproc/imgproc.hpp
@@ -558,6 +558,9 @@ CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
 //! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
 CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM );
 
+CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst );
+CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst );
+
 //! extracts rectangle from the image at sub-pixel location
 CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
                                  Point2f center, OutputArray patch, int patchType=-1 );
@@ -574,16 +577,16 @@ CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
                                         int sdepth=-1 );
 
 //! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
-CV_EXPORTS_W void accumulate( InputArray src, CV_IN_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
                               InputArray mask=noArray() );
 //! adds squared src image to the accumulator (dst += src*src).
-CV_EXPORTS_W void accumulateSquare( InputArray src, CV_IN_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
                                     InputArray mask=noArray() );
 //! adds product of the 2 images to the accumulator (dst += src1*src2).
 CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
-                                     CV_IN_OUT InputOutputArray dst, InputArray mask=noArray() );
+                                     InputOutputArray dst, InputArray mask=noArray() );
 //! updates the running average (dst = dst*(1-alpha) + src*alpha)
-CV_EXPORTS_W void accumulateWeighted( InputArray src, CV_IN_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
                                       double alpha, InputArray mask=noArray() );
     
 //! type of the threshold operation
@@ -660,6 +663,13 @@ CV_EXPORTS void calcHist( const Mat* images, int nimages,
                           SparseMat& hist, int dims,
                           const int* histSize, const float** ranges,
                           bool uniform=true, bool accumulate=false );
+                          
+CV_EXPORTS_W void calcHist( InputArrayOfArrays images,
+                            const vector<int>& channels,
+                            InputArray mask, OutputArray hist,
+                            const vector<int>& histSize,
+                            const vector<float>& ranges,
+                            bool accumulate=false );
 
 //! computes back projection for the set of images
 CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
@@ -673,6 +683,11 @@ CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
                                  OutputArray backProject, const float** ranges,
                                  double scale=1, bool uniform=true );
 
+CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const vector<int>& channels,
+                                   InputArray hist, OutputArray dst,
+                                   const vector<float>& ranges,
+                                   double scale );
+
 //! compares two histograms stored in dense arrays
 CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );
 
@@ -750,6 +765,150 @@ CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
                             Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
                             int flags=4 );
 
+    
+enum
+{
+    COLOR_BGR2BGRA    =0,
+    COLOR_RGB2RGBA    =COLOR_BGR2BGRA,
+    
+    COLOR_BGRA2BGR    =1,
+    COLOR_RGBA2RGB    =COLOR_BGRA2BGR,
+    
+    COLOR_BGR2RGBA    =2,
+    COLOR_RGB2BGRA    =COLOR_BGR2RGBA,
+    
+    COLOR_RGBA2BGR    =3,
+    COLOR_BGRA2RGB    =COLOR_RGBA2BGR,
+    
+    COLOR_BGR2RGB     =4,
+    COLOR_RGB2BGR     =COLOR_BGR2RGB,
+    
+    COLOR_BGRA2RGBA   =5,
+    COLOR_RGBA2BGRA   =COLOR_BGRA2RGBA,
+    
+    COLOR_BGR2GRAY    =6,
+    COLOR_RGB2GRAY    =7,
+    COLOR_GRAY2BGR    =8,
+    COLOR_GRAY2RGB    =COLOR_GRAY2BGR,
+    COLOR_GRAY2BGRA   =9,
+    COLOR_GRAY2RGBA   =COLOR_GRAY2BGRA,
+    COLOR_BGRA2GRAY   =10,
+    COLOR_RGBA2GRAY   =11,
+    
+    COLOR_BGR2BGR565  =12,
+    COLOR_RGB2BGR565  =13,
+    COLOR_BGR5652BGR  =14,
+    COLOR_BGR5652RGB  =15,
+    COLOR_BGRA2BGR565 =16,
+    COLOR_RGBA2BGR565 =17,
+    COLOR_BGR5652BGRA =18,
+    COLOR_BGR5652RGBA =19,
+    
+    COLOR_GRAY2BGR565 =20,
+    COLOR_BGR5652GRAY =21,
+    
+    COLOR_BGR2BGR555  =22,
+    COLOR_RGB2BGR555  =23,
+    COLOR_BGR5552BGR  =24,
+    COLOR_BGR5552RGB  =25,
+    COLOR_BGRA2BGR555 =26,
+    COLOR_RGBA2BGR555 =27,
+    COLOR_BGR5552BGRA =28,
+    COLOR_BGR5552RGBA =29,
+    
+    COLOR_GRAY2BGR555 =30,
+    COLOR_BGR5552GRAY =31,
+    
+    COLOR_BGR2XYZ     =32,
+    COLOR_RGB2XYZ     =33,
+    COLOR_XYZ2BGR     =34,
+    COLOR_XYZ2RGB     =35,
+    
+    COLOR_BGR2YCrCb   =36,
+    COLOR_RGB2YCrCb   =37,
+    COLOR_YCrCb2BGR   =38,
+    COLOR_YCrCb2RGB   =39,
+    
+    COLOR_BGR2HSV     =40,
+    COLOR_RGB2HSV     =41,
+    
+    COLOR_BGR2Lab     =44,
+    COLOR_RGB2Lab     =45,
+    
+    COLOR_BayerBG2BGR =46,
+    COLOR_BayerGB2BGR =47,
+    COLOR_BayerRG2BGR =48,
+    COLOR_BayerGR2BGR =49,
+    
+    COLOR_BayerBG2RGB =COLOR_BayerRG2BGR,
+    COLOR_BayerGB2RGB =COLOR_BayerGR2BGR,
+    COLOR_BayerRG2RGB =COLOR_BayerBG2BGR,
+    COLOR_BayerGR2RGB =COLOR_BayerGB2BGR,
+    
+    COLOR_BGR2Luv     =50,
+    COLOR_RGB2Luv     =51,
+    COLOR_BGR2HLS     =52,
+    COLOR_RGB2HLS     =53,
+    
+    COLOR_HSV2BGR     =54,
+    COLOR_HSV2RGB     =55,
+    
+    COLOR_Lab2BGR     =56,
+    COLOR_Lab2RGB     =57,
+    COLOR_Luv2BGR     =58,
+    COLOR_Luv2RGB     =59,
+    COLOR_HLS2BGR     =60,
+    COLOR_HLS2RGB     =61,
+    
+    COLOR_BayerBG2BGR_VNG =62,
+    COLOR_BayerGB2BGR_VNG =63,
+    COLOR_BayerRG2BGR_VNG =64,
+    COLOR_BayerGR2BGR_VNG =65,
+    
+    COLOR_BayerBG2RGB_VNG =COLOR_BayerRG2BGR_VNG,
+    COLOR_BayerGB2RGB_VNG =COLOR_BayerGR2BGR_VNG,
+    COLOR_BayerRG2RGB_VNG =COLOR_BayerBG2BGR_VNG,
+    COLOR_BayerGR2RGB_VNG =COLOR_BayerGB2BGR_VNG,
+    
+    COLOR_BGR2HSV_FULL = 66,
+    COLOR_RGB2HSV_FULL = 67,
+    COLOR_BGR2HLS_FULL = 68,
+    COLOR_RGB2HLS_FULL = 69,
+    
+    COLOR_HSV2BGR_FULL = 70,
+    COLOR_HSV2RGB_FULL = 71,
+    COLOR_HLS2BGR_FULL = 72,
+    COLOR_HLS2RGB_FULL = 73,
+    
+    COLOR_LBGR2Lab     = 74,
+    COLOR_LRGB2Lab     = 75,
+    COLOR_LBGR2Luv     = 76,
+    COLOR_LRGB2Luv     = 77,
+    
+    COLOR_Lab2LBGR     = 78,
+    COLOR_Lab2LRGB     = 79,
+    COLOR_Luv2LBGR     = 80,
+    COLOR_Luv2LRGB     = 81,
+    
+    COLOR_BGR2YUV      = 82,
+    COLOR_RGB2YUV      = 83,
+    COLOR_YUV2BGR      = 84,
+    COLOR_YUV2RGB      = 85,
+    
+    COLOR_BayerBG2GRAY = 86,
+    COLOR_BayerGB2GRAY = 87,
+    COLOR_BayerRG2GRAY = 88,
+    COLOR_BayerGR2GRAY = 89,
+    
+    COLOR_YUV420i2RGB  = 90,
+    COLOR_YUV420i2BGR  = 91,
+    COLOR_YUV420sp2RGB = 92,
+    COLOR_YUV420sp2BGR = 93,
+    
+    COLOR_COLORCVT_MAX  =100
+};
+    
+    
 //! converts image from one color space to another
 CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 );
 
@@ -780,6 +939,7 @@ CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false );
 
 //! computes 7 Hu invariants from the moments
 CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
+CV_EXPORTS_W void HuMoments( const Moments& m, CV_OUT OutputArray hu );
 
 //! type of the template matching operation
 enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 };
@@ -837,7 +997,7 @@ CV_EXPORTS_W double contourArea( InputArray contour, bool oriented=false );
 CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );
 //! computes the minimal enclosing circle for a set of points
 CV_EXPORTS_W void minEnclosingCircle( InputArray points,
-                                      Point2f& center, float& radius );    
+                                      CV_OUT Point2f& center, CV_OUT float& radius );    
 //! matches two contours using one of the available algorithms
 CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
                                  int method, double parameter );
@@ -857,6 +1017,98 @@ CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
 //! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
 CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );
         
+
+class CV_EXPORTS_W Subdiv2D
+{
+public:
+    enum
+    {
+        PTLOC_ERROR = -2,
+        PTLOC_OUTSIDE_RECT = -1,
+        PTLOC_INSIDE = 0,
+        PTLOC_VERTEX = 1,
+        PTLOC_ON_EDGE = 2
+    };
+    
+    enum
+    {
+        NEXT_AROUND_ORG   = 0x00,
+        NEXT_AROUND_DST   = 0x22,
+        PREV_AROUND_ORG   = 0x11,
+        PREV_AROUND_DST   = 0x33,
+        NEXT_AROUND_LEFT  = 0x13,
+        NEXT_AROUND_RIGHT = 0x31,
+        PREV_AROUND_LEFT  = 0x20,
+        PREV_AROUND_RIGHT = 0x02
+    };
+    
+    CV_WRAP Subdiv2D();
+    CV_WRAP Subdiv2D(Rect rect);
+    CV_WRAP void initDelaunay(Rect rect);
+    
+    CV_WRAP int insert(Point2f pt);
+    CV_WRAP void insert(const vector<Point2f>& ptvec);
+    CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex);
+    
+    CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt=0);
+    CV_WRAP void getEdgeList(CV_OUT vector<Vec4f>& edgeList) const;
+    CV_WRAP void getTriangleList(CV_OUT vector<Vec6f>& triangleList) const;
+    CV_WRAP void getVoronoiFacetList(const vector<int>& idx, CV_OUT vector<vector<Point2f> >& facetList,
+                                     CV_OUT vector<Point2f>& facetCenters);
+    
+    CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge=0) const;
+    
+    CV_WRAP int getEdge( int edge, int nextEdgeType ) const;
+    CV_WRAP int nextEdge(int edge) const;
+    CV_WRAP int rotateEdge(int edge, int rotate) const;
+    CV_WRAP int symEdge(int edge) const;
+    CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt=0) const;
+    CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt=0) const;
+    
+protected:
+    int newEdge();
+    void deleteEdge(int edge);
+    int newPoint(Point2f pt, bool isvirtual, int firstEdge=0);
+    void deletePoint(int vtx);
+    void setEdgePoints( int edge, int orgPt, int dstPt );
+    void splice( int edgeA, int edgeB );
+    int connectEdges( int edgeA, int edgeB );
+    void swapEdges( int edge );
+    int isRightOf(Point2f pt, int edge) const;
+    void calcVoronoi();
+    void clearVoronoi();
+    void check() const;
+    
+    struct CV_EXPORTS Vertex
+    {
+        Vertex();
+        Vertex(Point2f pt, bool _isvirtual, int _firstEdge=0);
+        bool isvirtual() const;
+        bool isfree() const;
+        int firstEdge;
+        int type;
+        Point2f pt;
+    };
+    struct CV_EXPORTS QuadEdge
+    {
+        QuadEdge();
+        QuadEdge(int edgeidx);
+        bool isfree() const;
+        int next[4];
+        int pt[4];
+    };
+    
+    vector<Vertex> vtx;
+    vector<QuadEdge> qedges;
+    int freeQEdge;
+    int freePoint;
+    bool validGeometry;
+    
+    int recentEdge;
+    Point2f topLeft;
+    Point2f bottomRight;
+};
+
 }
 
 // 2009-01-12, Xavier Delacour <xavier.delacour@gmail.com>
diff --git a/modules/imgproc/include/opencv2/imgproc/types_c.h b/modules/imgproc/include/opencv2/imgproc/types_c.h
index 7c3b5a37ee..5a984fd625 100644
--- a/modules/imgproc/include/opencv2/imgproc/types_c.h
+++ b/modules/imgproc/include/opencv2/imgproc/types_c.h
@@ -228,6 +228,8 @@ enum
 
     CV_YUV420i2RGB  = 90,
     CV_YUV420i2BGR  = 91,
+    CV_YUV420sp2RGB = 92,
+    CV_YUV420sp2BGR = 93,
     
     CV_COLORCVT_MAX  =100
 };
diff --git a/modules/imgproc/src/accum.cpp b/modules/imgproc/src/accum.cpp
index a099fcbae0..4a588f8fcf 100644
--- a/modules/imgproc/src/accum.cpp
+++ b/modules/imgproc/src/accum.cpp
@@ -417,7 +417,7 @@ void cv::accumulateProduct( InputArray _src1, InputArray _src2,
 }
 
 
-void cv::accumulateWeighted( InputArray _src, CV_IN_OUT InputOutputArray _dst,
+void cv::accumulateWeighted( InputArray _src, InputOutputArray _dst,
                              double alpha, InputArray _mask )
 {
     Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
diff --git a/modules/imgproc/src/color.cpp b/modules/imgproc/src/color.cpp
index b9748c8a08..b7e0360c51 100644
--- a/modules/imgproc/src/color.cpp
+++ b/modules/imgproc/src/color.cpp
@@ -2648,16 +2648,16 @@ static void Bayer2RGB_VNG_8u( const Mat& srcmat, Mat& dstmat, int code )
     }
 }
 
-///////////////////////////////////// YUV420i -> RGB /////////////////////////////////////
+///////////////////////////////////// YUV420 -> RGB /////////////////////////////////////
 
-template<int R>
-struct YUV420i2BGR888Invoker
+template<int R, int SPorI>
+struct YUV4202BGR888Invoker
 {
     Mat* dst;
     const uchar* my1, *muv;
     int width;
 
-    YUV420i2BGR888Invoker(Mat& _dst, int _width, const uchar* _y1, const uchar* _uv)
+    YUV4202BGR888Invoker(Mat& _dst, int _width, const uchar* _y1, const uchar* _uv)
         : dst(&_dst), my1(_y1), muv(_uv), width(_width) {}
 
     void operator()(const BlockedRange& range) const
@@ -2676,8 +2676,8 @@ struct YUV420i2BGR888Invoker
 
             for(int i = 0; i < width; i+=2,row1+=6,row2+=6)
             {
-                int cr = uv[i] - 128;
-                int cb = uv[i+1] - 128;
+                int cr = uv[i + SPorI + 0] - 128;
+                int cb = uv[i - SPorI + 1] - 128;
 
                 int ruv = 409 * cr + 128;
                 int guv = 128 - 100 * cb - 208 * cr;
@@ -2707,14 +2707,14 @@ struct YUV420i2BGR888Invoker
     }
 };
 
-template<int R>
-struct YUV420i2BGRA8888Invoker
+template<int R, int SPorI>
+struct YUV4202BGRA8888Invoker
 {
     Mat* dst;
     const uchar* my1, *muv;
     int width;
 
-    YUV420i2BGRA8888Invoker(Mat& _dst, int _width, const uchar* _y1, const uchar* _uv)
+    YUV4202BGRA8888Invoker(Mat& _dst, int _width, const uchar* _y1, const uchar* _uv)
         : dst(&_dst), my1(_y1), muv(_uv), width(_width) {}
 
     void operator()(const BlockedRange& range) const
@@ -2733,8 +2733,8 @@ struct YUV420i2BGRA8888Invoker
 
             for(int i = 0; i < width; i+=2,row1+=8,row2+=8)
             {
-                int cr = uv[i] - 128;
-                int cb = uv[i+1] - 128;
+                int cr = uv[i + SPorI + 0] - 128;
+                int cb = uv[i - SPorI + 1] - 128;
 
                 int ruv = 409 * cr + 128;
                 int guv = 128 - 100 * cb - 208 * cr;
@@ -3112,7 +3112,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
                 Bayer2RGB_VNG_8u(src, dst, code);
             }
             break;
-        case CV_YUV420i2BGR: case CV_YUV420i2RGB:
+        case CV_YUV420sp2BGR: case CV_YUV420sp2RGB: case CV_YUV420i2BGR: case CV_YUV420i2RGB:
             {
                 if(dcn <= 0) dcn = 3;
                 CV_Assert( dcn == 3 || dcn == 4 );
@@ -3126,22 +3126,36 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
                 const uchar* uv = y + dstSz.area();
 
 #ifdef HAVE_TEGRA_OPTIMIZATION
-                if (!tegra::YUV420i2BGR(y, uv, dst, CV_YUV420i2RGB == code))
+                if (!tegra::YUV420i2BGR(y, uv, dst, CV_YUV420sp2RGB == code))
 #endif
                 {
-                    if (CV_YUV420i2RGB == code)
+                    if (CV_YUV420sp2RGB == code)
                     {
                         if (dcn == 3)
-                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV420i2BGR888Invoker<2>(dst, dstSz.width, y, uv));
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGR888Invoker<2,0>(dst, dstSz.width, y, uv));
                         else
-                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV420i2BGRA8888Invoker<2>(dst, dstSz.width, y, uv));
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGRA8888Invoker<2,0>(dst, dstSz.width, y, uv));
                     }
-                    else
+                    else if (CV_YUV420sp2BGR == code)
                     {
                         if (dcn == 3)
-                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV420i2BGR888Invoker<0>(dst, dstSz.width, y, uv));
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGR888Invoker<0,0>(dst, dstSz.width, y, uv));
                         else
-                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV420i2BGRA8888Invoker<0>(dst, dstSz.width, y, uv));
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGRA8888Invoker<0,0>(dst, dstSz.width, y, uv));
+                    }
+                    else if (CV_YUV420i2RGB == code)
+                    {
+                        if (dcn == 3)
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGR888Invoker<2,1>(dst, dstSz.width, y, uv));
+                        else
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGRA8888Invoker<2,1>(dst, dstSz.width, y, uv));
+                    }
+                    else if (CV_YUV420i2BGR == code)
+                    {
+                        if (dcn == 3)
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGR888Invoker<0,1>(dst, dstSz.width, y, uv));
+                        else
+                            parallel_for(BlockedRange(0, dstSz.height, 2), YUV4202BGRA8888Invoker<0,1>(dst, dstSz.width, y, uv));
                     }
                 }
             }
diff --git a/modules/imgproc/src/emd.cpp b/modules/imgproc/src/emd.cpp
index fd7f9a48e0..734e7aaaf9 100644
--- a/modules/imgproc/src/emd.cpp
+++ b/modules/imgproc/src/emd.cpp
@@ -1150,7 +1150,7 @@ float cv::EMD( InputArray _signature1, InputArray _signature2,
     CvMat _ccost = cost, _cflow;
     if( _flow.needed() )
     {
-        _flow.create((int)signature1.total(), (int)signature2.total(), CV_32F);
+        _flow.create(signature1.rows, signature2.rows, CV_32F);
         flow = _flow.getMat();
         _cflow = flow;
     }
diff --git a/modules/imgproc/src/filter.cpp b/modules/imgproc/src/filter.cpp
index b51e4ca2c8..6a90d3e4a3 100644
--- a/modules/imgproc/src/filter.cpp
+++ b/modules/imgproc/src/filter.cpp
@@ -437,6 +437,9 @@ void FilterEngine::apply(const Mat& src, Mat& dst,
     Rect srcRoi = _srcRoi;
     if( srcRoi == Rect(0,0,-1,-1) )
         srcRoi = Rect(0,0,src.cols,src.rows);
+    
+    if( srcRoi.area() == 0 )
+        return;
 
     CV_Assert( dstOfs.x >= 0 && dstOfs.y >= 0 &&
         dstOfs.x + srcRoi.width <= dst.cols &&
diff --git a/modules/imgproc/src/floodfill.cpp b/modules/imgproc/src/floodfill.cpp
index 6ddf196fdb..25b6a01db5 100644
--- a/modules/imgproc/src/floodfill.cpp
+++ b/modules/imgproc/src/floodfill.cpp
@@ -1132,7 +1132,7 @@ int cv::floodFill( InputOutputArray _image, InputOutputArray _mask,
 {
     CvConnectedComp ccomp;
     CvMat c_image = _image.getMat(), c_mask = _mask.getMat();
-    cvFloodFill(&c_image, seedPoint, newVal, loDiff, upDiff, &ccomp, flags, &c_mask);
+    cvFloodFill(&c_image, seedPoint, newVal, loDiff, upDiff, &ccomp, flags, c_mask.data.ptr ? &c_mask : 0);
     if( rect )
         *rect = ccomp.rect;
     return cvRound(ccomp.area);
diff --git a/modules/imgproc/src/geometry.cpp b/modules/imgproc/src/geometry.cpp
index b12d098486..ab0bc7565d 100644
--- a/modules/imgproc/src/geometry.cpp
+++ b/modules/imgproc/src/geometry.cpp
@@ -169,7 +169,7 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
             CvRect r = ((CvContour*)contour)->rect;
             if( pt.x < r.x || pt.y < r.y ||
                 pt.x >= r.x + r.width || pt.y >= r.y + r.height )
-                return -100;
+                return -1;
         }
     }
     else if( CV_IS_SEQ_CHAIN(contour) )
@@ -214,7 +214,7 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
             counter += dist > 0;
         }
 
-        result = counter % 2 == 0 ? -100 : 100;
+        result = counter % 2 == 0 ? -1 : 1;
     }
     else
     {
@@ -265,7 +265,7 @@ cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
                 counter += dist > 0;
             }
 
-            result = counter % 2 == 0 ? -100 : 100;
+            result = counter % 2 == 0 ? -1 : 1;
         }
         else
         {
diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp
index 7ef258805f..8d1dd6f956 100644
--- a/modules/imgproc/src/histogram.cpp
+++ b/modules/imgproc/src/histogram.cpp
@@ -634,6 +634,7 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
     ihist.convertTo(hist, CV_32F);
 }
 
+
 namespace cv
 {
 
@@ -824,7 +825,36 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
               ranges, uniform, accumulate, false );
 }
 
+
+void cv::calcHist( InputArrayOfArrays images, const vector<int>& channels,
+                   InputArray mask, OutputArray hist,
+                   const vector<int>& histSize,
+                   const vector<float>& ranges,
+                   bool accumulate )
+{
+    int i, dims = (int)histSize.size(), rsz = (int)ranges.size(), csz = (int)channels.size();
+    int nimages = (int)images.total();
     
+    CV_Assert(nimages > 0 && dims > 0);
+    CV_Assert(rsz == dims*2 || (rsz == 0 && images.depth(0) == CV_8U));
+    CV_Assert(csz == 0 || csz == dims);
+    float* _ranges[CV_MAX_DIM];
+    if( rsz > 0 )
+    {
+        for( i = 0; i < rsz/2; i++ )
+            _ranges[i] = (float*)&ranges[i*2];
+    }
+    
+    AutoBuffer<Mat> buf(nimages);
+    for( i = 0; i < nimages; i++ )
+        buf[i] = images.getMat(i);
+    
+    calcHist(&buf[0], nimages, csz ? &channels[0] : 0,
+            mask, hist, dims, &histSize[0], rsz ? (const float**)_ranges : 0,
+            true, accumulate);
+}
+
+
 /////////////////////////////////////// B A C K   P R O J E C T ////////////////////////////////////    
     
 namespace cv
@@ -1314,6 +1344,34 @@ void cv::calcBackProject( const Mat* images, int nimages, const int* channels,
         CV_Error(CV_StsUnsupportedFormat, "");
 }
 
+                                     
+void cv::calcBackProject( InputArrayOfArrays images, const vector<int>& channels,
+                          InputArray hist, OutputArray dst,
+                          const vector<float>& ranges,
+                          double scale )
+{
+    Mat H = hist.getMat();
+    bool _1d = H.rows == 1 || H.cols == 1;
+    int i, dims = H.dims, rsz = (int)ranges.size(), csz = (int)channels.size();
+    int nimages = (int)images.total();
+    CV_Assert(nimages > 0);
+    CV_Assert(rsz == dims*2 || (rsz == 2 && _1d) || (rsz == 0 && images.depth(0) == CV_8U));
+    CV_Assert(csz == 0 || csz == dims || (csz == 1 && _1d));
+    float* _ranges[CV_MAX_DIM];
+    if( rsz > 0 )
+    {
+        for( i = 0; i < rsz/2; i++ )
+            _ranges[i] = (float*)&ranges[i*2];
+    }
+    
+    AutoBuffer<Mat> buf(nimages);
+    for( i = 0; i < nimages; i++ )
+        buf[i] = images.getMat(i);
+    
+    calcBackProject(&buf[0], nimages, csz ? &channels[0] : 0,
+        hist, dst, rsz ? (const float**)_ranges : 0, scale, true);
+}
+
     
 ////////////////// C O M P A R E   H I S T O G R A M S ////////////////////////    
 
diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp
index 1a1de02436..30eda4a950 100644
--- a/modules/imgproc/src/imgwarp.cpp
+++ b/modules/imgproc/src/imgwarp.cpp
@@ -3187,6 +3187,22 @@ void cv::invertAffineTransform(InputArray _matM, OutputArray __iM)
         CV_Error( CV_StsUnsupportedFormat, "" );
 }    
 
+
+cv::Mat cv::getPerspectiveTransform(InputArray _src, InputArray _dst)
+{
+    Mat src = _src.getMat(), dst = _dst.getMat();
+    CV_Assert(src.checkVector(2, CV_32F) == 4 && dst.checkVector(2, CV_32F) == 4);
+    return getPerspectiveTransform((const Point2f*)src.data, (const Point2f*)dst.data);
+}
+
+cv::Mat cv::getAffineTransform(InputArray _src, InputArray _dst)
+{
+    Mat src = _src.getMat(), dst = _dst.getMat();
+    CV_Assert(src.checkVector(2, CV_32F) == 3 && dst.checkVector(2, CV_32F) == 3);
+    return getAffineTransform((const Point2f*)src.data, (const Point2f*)dst.data);
+}
+
+
 CV_IMPL void
 cvResize( const CvArr* srcarr, CvArr* dstarr, int method )
 {
diff --git a/modules/imgproc/src/lsh.cpp b/modules/imgproc/src/lsh.cpp
index 6e594d94d2..75e1016e17 100644
--- a/modules/imgproc/src/lsh.cpp
+++ b/modules/imgproc/src/lsh.cpp
@@ -117,14 +117,14 @@ public:
       free_nodes.pop_back();
     }
     node& n = nodes[ii];
-    int h1 = h.h1 % bins.size();
+    int h1 = (int)(h.h1 % bins.size());
     n.i = i;
     n.h2 = h.h2;
     n.next = bins[h1];
     bins[h1] = ii;
   }
   virtual void hash_remove(lsh_hash h, int /*l*/, int i) {
-    int h1 = h.h1 % bins.size();
+    int h1 = (int)(h.h1 % bins.size());
     for (int ii = bins[h1], iin, iip = -1; ii != -1; iip = ii, ii = iin) {
       iin = nodes[ii].next;
       if (nodes[ii].h2 == h.h2 && nodes[ii].i == i) {
@@ -137,7 +137,7 @@ public:
     }
   }
   virtual int hash_lookup(lsh_hash h, int /*l*/, int* ret_i, int ret_i_max) {
-    int h1 = h.h1 % bins.size();
+    int h1 = (int)(h.h1 % bins.size());
     int k = 0;
     for (int ii = bins[h1]; ii != -1 && k < ret_i_max; ii = nodes[ii].next)
       if (nodes[ii].h2 == h.h2)
diff --git a/modules/imgproc/src/moments.cpp b/modules/imgproc/src/moments.cpp
index 7bdc38a089..aa1a569e3a 100644
--- a/modules/imgproc/src/moments.cpp
+++ b/modules/imgproc/src/moments.cpp
@@ -199,16 +199,16 @@ static void icvContourMoments( CvSeq* contour, CvMoments* moments )
 template<typename T, typename WT, typename MT>
 static void momentsInTile( const cv::Mat& img, double* moments )
 {
-	cv::Size size = img.size();
+    cv::Size size = img.size();
     int x, y;
     MT mom[10] = {0,0,0,0,0,0,0,0,0,0};
 
     for( y = 0; y < size.height; y++ )
     {
-		const T* ptr = (const T*)(img.data + y*img.step);
-		WT x0 = 0, x1 = 0, x2 = 0;
-		MT x3 = 0;
-		
+        const T* ptr = (const T*)(img.data + y*img.step);
+        WT x0 = 0, x1 = 0, x2 = 0;
+        MT x3 = 0;
+        
         for( x = 0; x < size.width; x++ )
         {
             WT p = ptr[x];
@@ -216,7 +216,7 @@ static void momentsInTile( const cv::Mat& img, double* moments )
 
             x0 += p;
             x1 += xp;
-			xxp = xp * x;
+            xxp = xp * x;
             x2 += xxp;
             x3 += xxp * x;
         }
@@ -244,7 +244,7 @@ static void momentsInTile( const cv::Mat& img, double* moments )
 
 template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* moments )
 {
-	typedef uchar T;
+    typedef uchar T;
     typedef int WT;
     typedef int MT;
     cv::Size size = img.size();
@@ -254,8 +254,8 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
     
     for( y = 0; y < size.height; y++ )
     {
-		const T* ptr = img.ptr<T>(y);
-		int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0;
+        const T* ptr = img.ptr<T>(y);
+        int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0;
         
         if( useSIMD )
         {
@@ -285,7 +285,7 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
             _mm_store_si128((__m128i*)buf, qx3);
             x3 = buf[0] + buf[1] + buf[2] + buf[3];
         }
-		
+        
         for( ; x < size.width; x++ )
         {
             WT p = ptr[x];
@@ -293,7 +293,7 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
             
             x0 += p;
             x1 += xp;
-			xxp = xp * x;
+            xxp = xp * x;
             x2 += xxp;
             x3 += xxp * x;
         }
@@ -322,15 +322,15 @@ typedef void (*CvMomentsInTileFunc)(const cv::Mat& img, double* moments);
 
 CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
 {
-	const int TILE_SIZE = 32;
-	int type, depth, cn, coi = 0;
+    const int TILE_SIZE = 32;
+    int type, depth, cn, coi = 0;
     CvMat stub, *mat = (CvMat*)array;
     CvMomentsInTileFunc func = 0;
     CvContour contourHeader;
     CvSeq* contour = 0;
     CvSeqBlock block;
-	double buf[TILE_SIZE*TILE_SIZE];
-	uchar nzbuf[TILE_SIZE*TILE_SIZE];
+    double buf[TILE_SIZE*TILE_SIZE];
+    uchar nzbuf[TILE_SIZE*TILE_SIZE];
 
     if( CV_IS_SEQ( array ))
     {
@@ -375,47 +375,47 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
     if( size.width <= 0 || size.height <= 0 )
         return;
 
-	if( binary || depth == CV_8U )
-		func = momentsInTile<uchar, int, int>;
-	else if( depth == CV_16U )
-		func = momentsInTile<ushort, int, int64>;
-	else if( depth == CV_16S )
-		func = momentsInTile<short, int, int64>;
-	else if( depth == CV_32F )
-		func = momentsInTile<float, double, double>;
-	else if( depth == CV_64F )
-		func = momentsInTile<double, double, double>;
-	else
-		CV_Error( CV_StsUnsupportedFormat, "" );
-		
-	cv::Mat src0(mat);
+    if( binary || depth == CV_8U )
+        func = momentsInTile<uchar, int, int>;
+    else if( depth == CV_16U )
+        func = momentsInTile<ushort, int, int64>;
+    else if( depth == CV_16S )
+        func = momentsInTile<short, int, int64>;
+    else if( depth == CV_32F )
+        func = momentsInTile<float, double, double>;
+    else if( depth == CV_64F )
+        func = momentsInTile<double, double, double>;
+    else
+        CV_Error( CV_StsUnsupportedFormat, "" );
+        
+    cv::Mat src0(mat);
 
     for( int y = 0; y < size.height; y += TILE_SIZE )
     {
         cv::Size tileSize;
-		tileSize.height = std::min(TILE_SIZE, size.height - y);
+        tileSize.height = std::min(TILE_SIZE, size.height - y);
         
         for( int x = 0; x < size.width; x += TILE_SIZE )
         {
             tileSize.width = std::min(TILE_SIZE, size.width - x);
-			cv::Mat src(src0, cv::Rect(x, y, tileSize.width, tileSize.height));
+            cv::Mat src(src0, cv::Rect(x, y, tileSize.width, tileSize.height));
 
-			if( coi > 0 )
-			{
-				cv::Mat tmp(tileSize, depth, buf);
-				int pairs[] = {coi-1, 0};
-				cv::mixChannels(&src, 1, &tmp, 1, pairs, 1);
-				src = tmp;
-			}
-			if( binary )
-			{
-				cv::Mat tmp(tileSize, CV_8U, nzbuf);
-				cv::compare( src, 0, tmp, CV_CMP_NE );
+            if( coi > 0 )
+            {
+                cv::Mat tmp(tileSize, depth, buf);
+                int pairs[] = {coi-1, 0};
+                cv::mixChannels(&src, 1, &tmp, 1, pairs, 1);
                 src = tmp;
-			}
-			
-			double mom[10];
-			func( src, mom );
+            }
+            if( binary )
+            {
+                cv::Mat tmp(tileSize, CV_8U, nzbuf);
+                cv::compare( src, 0, tmp, CV_CMP_NE );
+                src = tmp;
+            }
+            
+            double mom[10];
+            func( src, mom );
             
             if(binary)
             {
@@ -423,10 +423,10 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
                 for( int k = 0; k < 10; k++ )
                     mom[k] *= s;
             }
-			
+            
             double xm = x * mom[0], ym = y * mom[0];
 
-			// accumulate moments computed in each tile 
+            // accumulate moments computed in each tile 
 
             // + m00 ( = m00' )
             moments->m00 += mom[0];
@@ -460,7 +460,7 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
         }
     }
 
-	icvCompleteMomentState( moments );
+    icvCompleteMomentState( moments );
 }
 
 
@@ -526,7 +526,7 @@ CV_IMPL double cvGetCentralMoment( CvMoments * moments, int x_order, int y_order
         CV_Error( CV_StsOutOfRange, "" );
 
     return order >= 2 ? (&(moments->m00))[4 + order * 3 + y_order] :
-		   order == 0 ? moments->m00 : 0;
+           order == 0 ? moments->m00 : 0;
 }
 
 
@@ -640,5 +640,12 @@ void cv::HuMoments( const Moments& m, double hu[7] )
     hu[6] = q1 * t0 - q0 * t1;
 }
 
+void cv::HuMoments( const Moments& m, OutputArray _hu )
+{
+    _hu.create(7, 1, CV_64F);
+    Mat hu = _hu.getMat();
+    CV_Assert( hu.isContinuous() );
+    HuMoments(m, (double*)hu.data);
+}
 
 /* End of file. */
diff --git a/modules/imgproc/src/subdivision2d.cpp b/modules/imgproc/src/subdivision2d.cpp
index 8034b7b4d6..43df79c9a5 100644
--- a/modules/imgproc/src/subdivision2d.cpp
+++ b/modules/imgproc/src/subdivision2d.cpp
@@ -710,4 +710,785 @@ cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt )
     return point;
 }
 
+
+namespace cv
+{
+    
+int Subdiv2D::nextEdge(int edge) const
+{
+    CV_DbgAssert((size_t)(edge >> 2) < qedges.size());
+    return qedges[edge >> 2].next[edge & 3];
+}
+
+int Subdiv2D::rotateEdge(int edge, int rotate) const
+{
+    return (edge & ~3) + ((edge + rotate) & 3);
+}
+
+int Subdiv2D::symEdge(int edge) const
+{
+    return edge ^ 2;
+}
+
+int Subdiv2D::getEdge(int edge, int nextEdgeType) const
+{
+    CV_DbgAssert((size_t)(edge >> 2) < qedges.size());
+    edge = qedges[edge >> 2].next[(edge + nextEdgeType) & 3];
+    return (edge & ~3) + ((edge + (nextEdgeType >> 4)) & 3);
+}
+
+int Subdiv2D::edgeOrg(int edge, CV_OUT Point2f* orgpt) const
+{
+    CV_DbgAssert((size_t)(edge >> 2) < qedges.size());
+    int vidx = qedges[edge >> 2].pt[edge & 3];
+    if( orgpt )
+    {
+        CV_DbgAssert((size_t)vidx < vtx.size());
+        *orgpt = vtx[vidx].pt;
+    }
+    return vidx;
+}
+
+int Subdiv2D::edgeDst(int edge, CV_OUT Point2f* dstpt) const
+{
+    CV_DbgAssert((size_t)(edge >> 2) < qedges.size());
+    int vidx = qedges[edge >> 2].pt[(edge + 2) & 3];
+    if( dstpt )
+    {
+        CV_DbgAssert((size_t)vidx < vtx.size());
+        *dstpt = vtx[vidx].pt;
+    }
+    return vidx;
+}
+
+
+Point2f Subdiv2D::getVertex(int vertex, CV_OUT int* firstEdge) const
+{
+    CV_DbgAssert((size_t)vertex < vtx.size());
+    if( firstEdge )
+        *firstEdge = vtx[vertex].firstEdge;
+    return vtx[vertex].pt;
+}
+
+
+Subdiv2D::Subdiv2D()
+{
+    validGeometry = false;
+    freeQEdge = 0;
+    freePoint = 0;
+    recentEdge = 0;
+}
+
+Subdiv2D::Subdiv2D(Rect rect)
+{
+    validGeometry = false;
+    freeQEdge = 0;
+    freePoint = 0;
+    recentEdge = 0;
+    
+    initDelaunay(rect);
+}
+
+
+Subdiv2D::QuadEdge::QuadEdge()
+{
+    next[0] = next[1] = next[2] = next[3] = 0;
+    pt[0] = pt[1] = pt[2] = pt[3] = 0;
+}
+
+Subdiv2D::QuadEdge::QuadEdge(int edgeidx)
+{
+    CV_DbgAssert((edgeidx & 3) == 0);
+    next[0] = edgeidx;
+    next[1] = edgeidx+3;
+    next[2] = edgeidx+2;
+    next[3] = edgeidx+1;
+    
+    pt[0] = pt[1] = pt[2] = pt[3] = 0;
+}
+
+bool Subdiv2D::QuadEdge::isfree() const
+{
+    return next[0] <= 0;
+}
+
+Subdiv2D::Vertex::Vertex()
+{
+    firstEdge = 0;
+    type = -1;
+}
+
+Subdiv2D::Vertex::Vertex(Point2f _pt, bool _isvirtual, int _firstEdge)
+{
+    firstEdge = _firstEdge;
+    type = (int)_isvirtual;
+    pt = _pt;
+}
+
+bool Subdiv2D::Vertex::isvirtual() const
+{
+    return type > 0;
+}
+
+bool Subdiv2D::Vertex::isfree() const
+{
+    return type < 0;
+}
+
+void Subdiv2D::splice( int edgeA, int edgeB )
+{
+    int& a_next = qedges[edgeA >> 2].next[edgeA & 3];
+    int& b_next = qedges[edgeB >> 2].next[edgeB & 3];
+    int a_rot = rotateEdge(a_next, 1);
+    int b_rot = rotateEdge(b_next, 1);
+    int& a_rot_next = qedges[a_rot >> 2].next[a_rot & 3];
+    int& b_rot_next = qedges[b_rot >> 2].next[b_rot & 3];
+    std::swap(a_next, b_next);
+    std::swap(a_rot_next, b_rot_next);
+}
+
+void Subdiv2D::setEdgePoints(int edge, int orgPt, int dstPt)
+{
+    qedges[edge >> 2].pt[edge & 3] = orgPt;
+    qedges[edge >> 2].pt[(edge + 2) & 3] = dstPt;
+    vtx[orgPt].firstEdge = edge;
+    vtx[dstPt].firstEdge = edge ^ 2;
+}
+
+int Subdiv2D::connectEdges( int edgeA, int edgeB )
+{
+    int edge = newEdge();
+    
+    splice(edge, getEdge(edgeA, NEXT_AROUND_LEFT));
+    splice(symEdge(edge), edgeB);
+    
+    setEdgePoints(edge, edgeDst(edgeA), edgeOrg(edgeB));
+    return edge;
+}
+
+void Subdiv2D::swapEdges( int edge )
+{
+    int sedge = symEdge(edge);
+    int a = getEdge(edge, PREV_AROUND_ORG);
+    int b = getEdge(sedge, PREV_AROUND_ORG);
+    
+    splice(edge, a);
+    splice(sedge, b);
+    
+    setEdgePoints(edge, edgeDst(a), edgeDst(b));
+    
+    splice(edge, getEdge(a, NEXT_AROUND_LEFT));
+    splice(sedge, getEdge(b, NEXT_AROUND_LEFT));
+}
+
+int Subdiv2D::isRightOf(Point2f pt, int edge) const
+{
+    Point2f org, dst;
+    edgeOrg(edge, &org);
+    edgeDst(edge, &dst);
+    double cw_area = cvTriangleArea( pt, dst, org );
+    
+    return (cw_area > 0) - (cw_area < 0);
+}
+
+
+int Subdiv2D::newEdge()
+{
+    if( freeQEdge <= 0 )
+    {
+        qedges.push_back(QuadEdge());
+        freeQEdge = (int)(qedges.size()-1);
+    }
+    int edge = freeQEdge*4;
+    freeQEdge = qedges[edge >> 2].next[1];
+    qedges[edge >> 2] = QuadEdge(edge);
+    return edge;
+}
+
+void Subdiv2D::deleteEdge(int edge)
+{
+    CV_DbgAssert((size_t)(edge >> 2) < (size_t)qedges.size());
+    splice( edge, getEdge(edge, PREV_AROUND_ORG) );
+    int sedge = symEdge(edge);
+    splice(sedge, getEdge(sedge, PREV_AROUND_ORG) );
+    
+    edge >>= 2;
+    qedges[edge].next[0] = 0;
+    qedges[edge].next[1] = freeQEdge;
+    freeQEdge = edge;
+}
+
+int Subdiv2D::newPoint(Point2f pt, bool isvirtual, int firstEdge)
+{
+    if( freePoint == 0 )
+    {
+        vtx.push_back(Vertex());
+        freePoint = (int)(vtx.size()-1);
+    }
+    int vidx = freePoint;
+    freePoint = vtx[vidx].firstEdge;
+    vtx[vidx] = Vertex(pt, isvirtual, firstEdge);
+    
+    return vidx;
+}
+
+void Subdiv2D::deletePoint(int vidx)
+{
+    CV_DbgAssert( (size_t)vidx < vtx.size() );
+    vtx[vidx].firstEdge = freePoint;
+    vtx[vidx].type = -1;
+    freePoint = vidx;
+}
+
+int Subdiv2D::locate(Point2f pt, int& _edge, int& _vertex)
+{
+    int vertex = 0;
+    
+    int i, maxEdges = (int)(qedges.size() * 4);
+    
+    if( qedges.size() < (size_t)4 )
+        CV_Error( CV_StsError, "Subdivision is empty" );
+    
+    if( pt.x < topLeft.x || pt.y < topLeft.y || pt.x >= bottomRight.x || pt.y >= bottomRight.y )
+        CV_Error( CV_StsOutOfRange, "" );
+    
+    int edge = recentEdge;
+    CV_Assert(edge > 0);
+    
+    int location = PTLOC_ERROR;
+    
+    int right_of_curr = isRightOf(pt, edge);
+    if( right_of_curr > 0 )
+    {
+        edge = symEdge(edge);
+        right_of_curr = -right_of_curr;
+    }
+    
+    for( i = 0; i < maxEdges; i++ )
+    {
+        int onext_edge = nextEdge( edge );
+        int dprev_edge = getEdge( edge, PREV_AROUND_DST );
+        
+        int right_of_onext = isRightOf( pt, onext_edge );
+        int right_of_dprev = isRightOf( pt, dprev_edge );
+        
+        if( right_of_dprev > 0 )
+        {
+            if( right_of_onext > 0 || (right_of_onext == 0 && right_of_curr == 0) )
+            {
+                location = PTLOC_INSIDE;
+                break;
+            }
+            else
+            {
+                right_of_curr = right_of_onext;
+                edge = onext_edge;
+            }
+        }
+        else
+        {
+            if( right_of_onext > 0 )
+            {
+                if( right_of_dprev == 0 && right_of_curr == 0 )
+                {
+                    location = PTLOC_INSIDE;
+                    break;
+                }
+                else
+                {
+                    right_of_curr = right_of_dprev;
+                    edge = dprev_edge;
+                }
+            }
+            else if( right_of_curr == 0 &&
+                    isRightOf( vtx[edgeDst(onext_edge)].pt, edge ) >= 0 )
+            {
+                edge = symEdge( edge );
+            }
+            else
+            {
+                right_of_curr = right_of_onext;
+                edge = onext_edge;
+            }
+        }
+    }
+    
+    recentEdge = edge;
+    
+    if( location == PTLOC_INSIDE )
+    {
+        Point2f org_pt, dst_pt;
+        edgeOrg(edge, &org_pt);
+        edgeDst(edge, &dst_pt);
+        
+        double t1 = fabs( pt.x - org_pt.x );
+        t1 += fabs( pt.y - org_pt.y );
+        double t2 = fabs( pt.x - dst_pt.x );
+        t2 += fabs( pt.y - dst_pt.y );
+        double t3 = fabs( org_pt.x - dst_pt.x );
+        t3 += fabs( org_pt.y - dst_pt.y );
+        
+        if( t1 < FLT_EPSILON )
+        {
+            location = PTLOC_VERTEX;
+            vertex = edgeOrg( edge );
+            edge = 0;
+        }
+        else if( t2 < FLT_EPSILON )
+        {
+            location = PTLOC_VERTEX;
+            vertex = edgeDst( edge );
+            edge = 0;
+        }
+        else if( (t1 < t3 || t2 < t3) &&
+                fabs( cvTriangleArea( pt, org_pt, dst_pt )) < FLT_EPSILON )
+        {
+            location = PTLOC_ON_EDGE;
+            vertex = 0;
+        }
+    }
+    
+    if( location == PTLOC_ERROR )
+    {
+        edge = 0;
+        vertex = 0;
+    }
+    
+    _edge = edge;
+    _vertex = vertex;
+    
+    return location;
+}
+
+
+inline int
+isPtInCircle3( Point2f pt, Point2f a, Point2f b, Point2f c)
+{
+    const double eps = FLT_EPSILON*0.125;
+    double val = ((double)a.x * a.x + (double)a.y * a.y) * cvTriangleArea( b, c, pt );
+    val -= ((double)b.x * b.x + (double)b.y * b.y) * cvTriangleArea( a, c, pt );
+    val += ((double)c.x * c.x + (double)c.y * c.y) * cvTriangleArea( a, b, pt );
+    val -= ((double)pt.x * pt.x + (double)pt.y * pt.y) * cvTriangleArea( a, b, c );
+    
+    return val > eps ? 1 : val < -eps ? -1 : 0;
+}
+
+
+int Subdiv2D::insert(Point2f pt)
+{
+    int curr_point = 0, curr_edge = 0, deleted_edge = 0;
+    int location = locate( pt, curr_edge, curr_point );
+    
+    if( location == PTLOC_ERROR )
+        CV_Error( CV_StsBadSize, "" );
+    
+    if( location == PTLOC_OUTSIDE_RECT )
+        CV_Error( CV_StsOutOfRange, "" );
+    
+    if( location == PTLOC_VERTEX )
+        return curr_point;
+    
+    if( location == PTLOC_ON_EDGE )
+    {
+        deleted_edge = curr_edge;
+        recentEdge = curr_edge = getEdge( curr_edge, PREV_AROUND_ORG );
+        deleteEdge(deleted_edge);
+    }
+    else if( location == PTLOC_INSIDE )
+        ;
+    else
+        CV_Error_(CV_StsError, ("Subdiv2D::locate returned invalid location = %d", location) );
+    
+    assert( curr_edge != 0 );
+    validGeometry = false;
+    
+    curr_point = newPoint(pt, false);
+    int base_edge = newEdge();
+    int first_point = edgeOrg(curr_edge);
+    setEdgePoints(base_edge, first_point, curr_point);
+    splice(base_edge, curr_edge);
+    
+    do
+    {
+        base_edge = connectEdges( curr_edge, symEdge(base_edge) );
+        curr_edge = getEdge(base_edge, PREV_AROUND_ORG);
+    }
+    while( edgeDst(curr_edge) != first_point );
+    
+    curr_edge = getEdge( base_edge, PREV_AROUND_ORG );
+    
+    int i, max_edges = (int)(qedges.size()*4);
+    
+    for( i = 0; i < max_edges; i++ )
+    {
+        int temp_dst = 0, curr_org = 0, curr_dst = 0;
+        int temp_edge = getEdge( curr_edge, PREV_AROUND_ORG );
+        
+        temp_dst = edgeDst( temp_edge );
+        curr_org = edgeOrg( curr_edge );
+        curr_dst = edgeDst( curr_edge );
+        
+        if( isRightOf( vtx[temp_dst].pt, curr_edge ) > 0 &&
+           isPtInCircle3( vtx[curr_org].pt, vtx[temp_dst].pt,
+                         vtx[curr_dst].pt, vtx[curr_point].pt ) < 0 )
+        {
+            swapEdges( curr_edge );
+            curr_edge = getEdge( curr_edge, PREV_AROUND_ORG );
+        }
+        else if( curr_org == first_point )
+            break;
+        else
+            curr_edge = getEdge( nextEdge( curr_edge ), PREV_AROUND_LEFT );
+    }
+    
+    return curr_point;
+}
+
+void Subdiv2D::insert(const vector<Point2f>& ptvec)
+{
+    for( size_t i = 0; i < ptvec.size(); i++ )
+        insert(ptvec[i]);
+}
+
+void Subdiv2D::initDelaunay( Rect rect )
+{
+    float big_coord = 3.f * MAX( rect.width, rect.height );
+    float rx = (float)rect.x;
+    float ry = (float)rect.y;
+    
+    vtx.clear();
+    qedges.clear();
+    
+    recentEdge = 0;
+    validGeometry = false;
+    
+    topLeft = Point2f( rx, ry );
+    bottomRight = Point2f( rx + rect.width, ry + rect.height );
+    
+    Point2f ppA( rx + big_coord, ry );
+    Point2f ppB( rx, ry + big_coord );
+    Point2f ppC( rx - big_coord, ry - big_coord );
+    
+    vtx.push_back(Vertex());
+    qedges.push_back(QuadEdge());
+    
+    freeQEdge = 0;
+    freePoint = 0;
+    
+    int pA = newPoint(ppA, false);
+    int pB = newPoint(ppB, false);
+    int pC = newPoint(ppC, false);
+    
+    int edge_AB = newEdge();
+    int edge_BC = newEdge();
+    int edge_CA = newEdge();
+    
+    setEdgePoints( edge_AB, pA, pB );
+    setEdgePoints( edge_BC, pB, pC );
+    setEdgePoints( edge_CA, pC, pA );
+    
+    splice( edge_AB, symEdge( edge_CA ));
+    splice( edge_BC, symEdge( edge_AB ));
+    splice( edge_CA, symEdge( edge_BC ));
+    
+    recentEdge = edge_AB;
+}
+
+
+void Subdiv2D::clearVoronoi()
+{
+    size_t i, total = qedges.size();
+    
+    for( i = 0; i < total; i++ )
+        qedges[i].pt[1] = qedges[i].pt[3] = 0;
+    
+    total = vtx.size();
+    for( i = 0; i < total; i++ )
+    {
+        if( vtx[i].isvirtual() )
+            deletePoint((int)i);
+    }
+    
+    validGeometry = false;
+}
+
+
+static Point2f computeVoronoiPoint(Point2f org0, Point2f dst0, Point2f org1, Point2f dst1)
+{
+    double a0 = dst0.x - org0.x;
+    double b0 = dst0.y - org0.y;
+    double c0 = -0.5*(a0 * (dst0.x + org0.x) + b0 * (dst0.y + org0.y));
+    
+    double a1 = dst1.x - org1.x;
+    double b1 = dst1.y - org1.y;
+    double c1 = -0.5*(a1 * (dst1.x + org1.x) + b1 * (dst1.y + org1.y));
+    
+    double det = a0 * b1 - a1 * b0;
+    
+    if( det != 0 )
+    {
+        det = 1. / det;
+        return Point2f((float) ((b0 * c1 - b1 * c0) * det),
+                       (float) ((a1 * c0 - a0 * c1) * det));
+    }
+    
+    return Point2f(FLT_MAX, FLT_MAX);
+}
+
+
+void Subdiv2D::calcVoronoi()
+{
+    // check if it is already calculated
+    if( validGeometry )
+        return;
+    
+    clearVoronoi();
+    int i, total = (int)qedges.size();
+    
+    // loop through all quad-edges, except for the first 3 (#1, #2, #3 - 0 is reserved for "NULL" pointer)
+    for( i = 4; i < total; i++ )
+    {
+        QuadEdge& quadedge = qedges[i];
+        
+        if( quadedge.isfree() )
+            continue;
+        
+        int edge0 = (int)(i*4);
+        Point2f org0, dst0, org1, dst1;
+        
+        if( !quadedge.pt[3] )
+        {
+            int edge1 = getEdge( edge0, NEXT_AROUND_LEFT );
+            int edge2 = getEdge( edge1, NEXT_AROUND_LEFT );
+            
+            edgeOrg(edge0, &org0);
+            edgeDst(edge0, &dst0);
+            edgeOrg(edge1, &org1);
+            edgeDst(edge1, &dst1);
+            
+            Point2f virt_point = computeVoronoiPoint(org0, dst0, org1, dst1);
+            
+            if( fabs( virt_point.x ) < FLT_MAX * 0.5 &&
+               fabs( virt_point.y ) < FLT_MAX * 0.5 )
+            {
+                quadedge.pt[3] = qedges[edge1 >> 2].pt[3 - (edge1 & 2)] =
+                qedges[edge2 >> 2].pt[3 - (edge2 & 2)] = newPoint(virt_point, true);
+            }
+        }
+        
+        if( !quadedge.pt[1] )
+        {
+            int edge1 = getEdge( edge0, NEXT_AROUND_RIGHT );
+            int edge2 = getEdge( edge1, NEXT_AROUND_RIGHT );
+            
+            edgeOrg(edge0, &org0);
+            edgeDst(edge0, &dst0);
+            edgeOrg(edge1, &org1);
+            edgeDst(edge1, &dst1);
+            
+            Point2f virt_point = computeVoronoiPoint(org0, dst0, org1, dst1);
+            
+            if( fabs( virt_point.x ) < FLT_MAX * 0.5 &&
+               fabs( virt_point.y ) < FLT_MAX * 0.5 )
+            {
+                quadedge.pt[1] = qedges[edge1 >> 2].pt[1 + (edge1 & 2)] = 
+                qedges[edge2 >> 2].pt[1 + (edge2 & 2)] = newPoint(virt_point, true);
+            }
+        }
+    }
+    
+    validGeometry = true;
+}
+
+
+static int
+isRightOf2( const Point2f& pt, const Point2f& org, const Point2f& diff )
+{
+    double cw_area = ((double)org.x - pt.x)*diff.y - ((double)org.y - pt.y)*diff.x;
+    return (cw_area > 0) - (cw_area < 0);
+}
+
+
+int Subdiv2D::findNearest(Point2f pt, Point2f* nearestPt)
+{
+    if( !validGeometry )
+        calcVoronoi();
+    
+    int vertex = 0, edge = 0;
+    int loc = locate( pt, edge, vertex );
+    
+    if( loc != PTLOC_ON_EDGE && loc != PTLOC_INSIDE )
+        return vertex;
+    
+    vertex = 0;
+    
+    Point2f start;
+    edgeOrg(edge, &start);
+    Point2f diff = pt - start;
+    
+    edge = rotateEdge(edge, 1);
+    
+    int i, total = (int)vtx.size();
+    
+    for( i = 0; i < total; i++ )
+    {
+        Point2f t;
+        
+        for(;;)
+        {
+            CV_Assert( edgeDst(edge, &t) > 0 );
+            if( isRightOf2( t, start, diff ) >= 0 )
+                break;
+            
+            edge = getEdge( edge, NEXT_AROUND_LEFT );
+        }
+        
+        for(;;)
+        {
+            CV_Assert( edgeOrg( edge, &t ) > 0 );
+            
+            if( isRightOf2( t, start, diff ) < 0 )
+                break;
+            
+            edge = getEdge( edge, PREV_AROUND_LEFT );
+        }
+        
+        Point2f tempDiff;
+        edgeDst(edge, &tempDiff);
+        edgeOrg(edge, &t);
+        tempDiff -= t;
+        
+        if( isRightOf2( pt, t, tempDiff ) >= 0 )
+        {
+            vertex = edgeOrg(rotateEdge( edge, 3 ));
+            break;
+        }
+        
+        edge = symEdge( edge );
+    }
+    
+    if( nearestPt && vertex > 0 )
+        *nearestPt = vtx[vertex].pt;
+    
+    return vertex;
+}
+
+void Subdiv2D::getEdgeList(vector<Vec4f>& edgeList) const
+{
+    edgeList.clear();
+    
+    for( size_t i = 4; i < qedges.size(); i++ )
+    {
+        if( qedges[i].isfree() )
+            continue;
+        if( qedges[i].pt[0] > 0 && qedges[i].pt[2] > 0 )
+        {
+            Point2f org = vtx[qedges[i].pt[0]].pt;
+            Point2f dst = vtx[qedges[i].pt[2]].pt;
+            edgeList.push_back(Vec4f(org.x, org.y, dst.x, dst.y));
+        }
+    }
+}
+
+void Subdiv2D::getTriangleList(vector<Vec6f>& triangleList) const
+{
+    triangleList.clear();
+    int i, total = (int)(qedges.size()*4);
+    vector<bool> edgemask(total, false);
+    
+    for( i = 4; i < total; i += 2 )
+    {
+        if( edgemask[i] )
+            continue;
+        Point2f a, b, c;
+        int edge = i;
+        edgeOrg(edge, &a);
+        edgemask[edge] = true;
+        edge = getEdge(edge, NEXT_AROUND_LEFT);
+        edgeOrg(edge, &b);
+        edgemask[edge] = true;
+        edge = getEdge(edge, NEXT_AROUND_LEFT);
+        edgeOrg(edge, &c);
+        edgemask[edge] = true;
+        triangleList.push_back(Vec6f(a.x, a.y, b.x, b.y, c.x, c.y));
+    }
+}
+
+void Subdiv2D::getVoronoiFacetList(const vector<int>& idx,
+                                   CV_OUT vector<vector<Point2f> >& facetList,
+                                   CV_OUT vector<Point2f>& facetCenters)
+{
+    calcVoronoi();
+    facetList.clear();
+    facetCenters.clear();
+    
+    vector<Point2f> buf;
+    
+    size_t i, total;
+    if( idx.empty() )
+        i = 4, total = vtx.size();
+    else
+        i = 0, total = idx.size();
+    
+    for( ; i < total; i++ )
+    {
+        int k = idx.empty() ? (int)i : idx[i];
+        
+        if( vtx[k].isfree() || vtx[k].isvirtual() )
+            continue;
+        int edge = rotateEdge(vtx[k].firstEdge, 1), t = edge;       
+        
+        // gather points
+        buf.clear();
+        do
+        {
+            buf.push_back(vtx[edgeOrg(t)].pt);
+            t = getEdge( t, NEXT_AROUND_LEFT );
+        }
+        while( t != edge );
+        
+        facetList.push_back(buf);
+        facetCenters.push_back(vtx[k].pt);
+    }
+}
+
+
+void Subdiv2D::check() const
+{
+    int i, j, total = (int)qedges.size();
+    
+    for( i = 0; i < total; i++ )
+    {
+        const QuadEdge& qe = qedges[i];
+        
+        if( qe.isfree() )
+            continue;
+        
+        for( j = 0; j < 4; j++ )
+        {
+            int e = (int)(i*4 + j);
+            int o_next = nextEdge(e);
+            int o_prev = getEdge(e, PREV_AROUND_ORG );
+            int d_prev = getEdge(e, PREV_AROUND_DST );
+            int d_next = getEdge(e, NEXT_AROUND_DST );
+            
+            // check points
+            CV_Assert( edgeOrg(e) == edgeOrg(o_next));
+            CV_Assert( edgeOrg(e) == edgeOrg(o_prev));
+            CV_Assert( edgeDst(e) == edgeDst(d_next));
+            CV_Assert( edgeDst(e) == edgeDst(d_prev));
+            
+            if( j % 2 == 0 )
+            {
+                CV_Assert( edgeDst(o_next) == edgeOrg(d_prev));
+                CV_Assert( edgeDst(o_prev) == edgeOrg(d_next));
+                CV_Assert( getEdge(getEdge(getEdge(e,NEXT_AROUND_LEFT),NEXT_AROUND_LEFT),NEXT_AROUND_LEFT) == e );
+                CV_Assert( getEdge(getEdge(getEdge(e,NEXT_AROUND_RIGHT),NEXT_AROUND_RIGHT),NEXT_AROUND_RIGHT) == e);
+            }
+        }
+    }
+}    
+    
+}
+
 /* End of file. */
diff --git a/modules/imgproc/src/utils.cpp b/modules/imgproc/src/utils.cpp
index 85720f38ce..8ebcbadd60 100644
--- a/modules/imgproc/src/utils.cpp
+++ b/modules/imgproc/src/utils.cpp
@@ -212,11 +212,17 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
                            top, left, (int)src.elemSize(), borderType );
     else
     {
-        double buf[4];
-        scalarToRawData(value, buf, src.type());
+        int cn = src.channels(), cn1 = cn;
+        AutoBuffer<double> buf(cn);
+        if( cn > 4 )
+        {
+            CV_Assert( value[0] == value[1] && value[0] == value[2] && value[0] == value[3] );
+            cn1 = 1;
+        }
+        scalarToRawData(value, buf, CV_MAKETYPE(src.depth(), cn1), cn);
         copyMakeConstBorder_8u( src.data, src.step, src.size(),
                                 dst.data, dst.step, dst.size(),
-                                top, left, (int)src.elemSize(), (uchar*)buf );
+                                top, left, (int)src.elemSize(), (uchar*)(double*)buf );
     }
 }
 
diff --git a/modules/imgproc/test/test_color.cpp b/modules/imgproc/test/test_color.cpp
index 76c869209b..8c1da99da9 100644
--- a/modules/imgproc/test/test_color.cpp
+++ b/modules/imgproc/test/test_color.cpp
@@ -388,7 +388,7 @@ void CV_ColorCvtBaseTest::convert_backward( const Mat& src, const Mat& dst, Mat&
     else
     {
         int i, j, k;
-        int elem_size = src.elemSize(), elem_size1 = src.elemSize1();
+        int elem_size = (int)src.elemSize(), elem_size1 = (int)src.elemSize1();
         int width_n = src.cols*elem_size;
 
         for( i = 0; i < src.rows; i++ )
diff --git a/modules/imgproc/test/test_filter.cpp b/modules/imgproc/test/test_filter.cpp
index 05dcfdccba..3b6b65c159 100644
--- a/modules/imgproc/test/test_filter.cpp
+++ b/modules/imgproc/test/test_filter.cpp
@@ -224,7 +224,7 @@ int CV_MorphologyBaseTest::prepare_test_case( int test_case_idx )
     {
         eldata.resize(aperture_size.width*aperture_size.height);
         uchar* src = test_mat[INPUT][1].data;
-        int srcstep = test_mat[INPUT][1].step;
+        int srcstep = (int)test_mat[INPUT][1].step;
         int i, j, nonzero = 0;
 
         for( i = 0; i < aperture_size.height; i++ )
@@ -901,7 +901,7 @@ static void test_medianFilter( const Mat& src, Mat& dst, int m )
     vector<int> col_buf(m+1);
     vector<median_pair> _buf0(m*m+1), _buf1(m*m+1);
     median_pair *buf0 = &_buf0[0], *buf1 = &_buf1[0];
-    int step = src.step/src.elemSize();
+    int step = (int)(src.step/src.elemSize());
 
     assert( src.rows == dst.rows + m - 1 && src.cols == dst.cols + m - 1 &&
             src.type() == dst.type() && src.type() == CV_8UC1 );
@@ -1663,10 +1663,10 @@ static void test_integral( const Mat& img, Mat* sum, Mat* sqsum, Mat* tilted )
     double* sdata = sum->ptr<double>();
     double* sqdata = sqsum ? sqsum->ptr<double>() : 0;
     double* tdata = tilted ? tilted->ptr<double>() : 0;
-    int step = img.step/sizeof(data[0]);
-    int sstep = sum->step/sizeof(sdata[0]);
-    int sqstep = sqsum ? sqsum->step/sizeof(sqdata[0]) : 0;
-    int tstep = tilted ? tilted->step/sizeof(tdata[0]) : 0;
+    int step = (int)(img.step/sizeof(data[0]));
+    int sstep = (int)(sum->step/sizeof(sdata[0]));
+    int sqstep = sqsum ? (int)(sqsum->step/sizeof(sqdata[0])) : 0;
+    int tstep = tilted ? (int)(tilted->step/sizeof(tdata[0])) : 0;
     Size size = img.size();
 
     memset( sdata, 0, (size.width+1)*sizeof(sdata[0]) );
diff --git a/modules/imgproc/test/test_imgwarp.cpp b/modules/imgproc/test/test_imgwarp.cpp
index f9aa53ea96..4aa20190c1 100644
--- a/modules/imgproc/test/test_imgwarp.cpp
+++ b/modules/imgproc/test/test_imgwarp.cpp
@@ -347,7 +347,7 @@ static void test_remap( const Mat& src, Mat& dst, const Mat& mapx, const Mat& ma
     uchar* sptr0 = src.data;
     int depth = src.depth(), cn = src.channels();
     int elem_size = (int)src.elemSize();
-    int step = src.step / CV_ELEM_SIZE(depth);
+    int step = (int)(src.step / CV_ELEM_SIZE(depth));
     int delta;
 
     if( interpolation != CV_INTER_CUBIC )
@@ -1100,7 +1100,7 @@ void CV_UndistortMapTest::prepare_to_validation( int )
 static void
 test_getQuadrangeSubPix( const Mat& src, Mat& dst, double* a )
 {
-    int sstep = src.step / sizeof(float);
+    int sstep = (int)(src.step / sizeof(float));
     int scols = src.cols, srows = src.rows;
     
     CV_Assert( src.depth() == CV_32F && src.type() == dst.type() );
diff --git a/modules/java/CMakeLists.txt b/modules/java/CMakeLists.txt
new file mode 100644
index 0000000000..6e4b7bacfe
--- /dev/null
+++ b/modules/java/CMakeLists.txt
@@ -0,0 +1,231 @@
+# ----------------------------------------------------------------------------
+#  CMake file for java support
+# ----------------------------------------------------------------------------
+project(opencv_java)
+set(target opencv_java)
+include_directories("${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/src/cpp")
+
+
+SET(OPENCV_JAVA_MODULES objdetect features2d imgproc video highgui ml core calib3d)
+SET(OPENCV_EXTRA_JAVA_MODULES contrib legacy flann)
+IF(WITH_ANDROID_CAMERA AND NOT BUILD_SHARED_LIBS)
+    LIST(APPEND OPENCV_EXTRA_JAVA_MODULES androidcamera)
+ENDIF()
+
+
+SET(GEN_JAVA "${CMAKE_CURRENT_SOURCE_DIR}/gen_java.py")
+SET(HDR_PARSER "${CMAKE_CURRENT_SOURCE_DIR}/../python/src2/hdr_parser.py")
+SET(GEN_JAVADOC "${CMAKE_CURRENT_SOURCE_DIR}/gen_javadoc.py")
+SET(RST_PARSER "${CMAKE_CURRENT_SOURCE_DIR}/rst_parser.py")
+SET(CHECK_TEST_COVERAGE "${CMAKE_CURRENT_SOURCE_DIR}/check-tests.py")
+
+# setup raw java and cpp files generation (without javadoc and at temporary location)
+foreach(module ${OPENCV_JAVA_MODULES})
+    # get list of module headers
+    IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/config/${module}.filelist")
+        FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/config/${module}.filelist" headers_to_parse)
+        SET (module_cheaders "")
+        SET (module_cppheaders "")
+        foreach(header ${headers_to_parse})
+            list(APPEND module_cppheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/${header}")
+        endforeach()
+    ELSE()
+        FILE(GLOB module_cheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include/opencv2/${module}/*.h")
+        FILE(GLOB module_cppheaders "${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include/opencv2/${module}/*.hpp")
+        list(SORT module_cheaders)
+        list(SORT module_cppheaders)
+    ENDIF()
+
+    # add dependencies to cmake (we should rerun cmake if any of these headers are modified)
+    foreach(header ${module_cheaders} ${module_cppheaders})
+        get_filename_component(header_name "${header}" NAME_WE)
+        configure_file("${header}" "${CMAKE_BINARY_DIR}/junk/${header_name}.junk" COPYONLY)
+    endforeach()
+
+    # the same about gen_java.py and hdr_parser.py
+    configure_file("${GEN_JAVA}" "${CMAKE_BINARY_DIR}/junk/gen_java.junk" COPYONLY)
+    configure_file("${HDR_PARSER}" "${CMAKE_BINARY_DIR}/junk/hdr_parser.junk" COPYONLY)
+
+
+    # first run (to get list of generated files)
+    file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out")
+    
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_cheaders} ${module_cppheaders}
+                  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out"
+                  OUTPUT_QUIET ERROR_QUIET)
+
+    # create list of generated files
+    file(GLOB_RECURSE generated_java_sources RELATIVE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/" "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/*.java")
+    file(REMOVE_RECURSE "${CMAKE_CURRENT_BINARY_DIR}/gen_java_out/")
+    
+    set(${module}_generated_java_sources)
+    foreach(f ${generated_java_sources})
+        list(APPEND ${module}_generated_java_sources "${CMAKE_CURRENT_BINARY_DIR}/${f}")
+    endforeach()
+
+    # second run
+    add_custom_command(
+        OUTPUT ${${module}_generated_java_sources}
+        OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp"
+        COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVA}" "${HDR_PARSER}" ${module} ${module_cheaders} ${module_cppheaders}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        DEPENDS "${GEN_JAVA}"
+        DEPENDS "${HDR_PARSER}"
+        DEPENDS ${module_cheaders}
+        DEPENDS ${module_cppheaders}
+        )
+endforeach()
+
+FILE(GLOB handwrittren_cpp_sources "${CMAKE_CURRENT_SOURCE_DIR}/src/cpp/*.cpp")
+FILE(GLOB handwrittren_h_sources "${CMAKE_CURRENT_SOURCE_DIR}/src/cpp/*.h*")
+FILE(GLOB handwrittren_java_sources "${CMAKE_CURRENT_SOURCE_DIR}/src/java/*.java")
+SET (generated_cpp_sources)
+SET (generated_java_sources)
+SET (documented_java_files)
+SET (undocumented_java_files)
+SET (dependent_libs)
+SET (dependent_extra_libs)
+
+foreach(module ${OPENCV_JAVA_MODULES})
+    LIST(APPEND generated_cpp_sources "${CMAKE_CURRENT_BINARY_DIR}/${module}.cpp")
+    LIST(APPEND generated_java_sources ${${module}_generated_java_sources})
+    LIST(APPEND dependent_libs opencv_${module})
+    include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include")
+endforeach()
+
+# extra includes and dependencies
+foreach(module ${OPENCV_EXTRA_JAVA_MODULES})
+    LIST(APPEND dependent_extra_libs opencv_${module})
+    include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../${module}/include")
+endforeach()
+
+# created list of documented files targets
+foreach(java_file ${handwrittren_java_sources} ${generated_java_sources})
+    get_filename_component(java_file_name "${java_file}" NAME_WE)
+    if (NOT java_file_name MATCHES ".*-jdoc$")
+        list(APPEND documented_java_files "${CMAKE_CURRENT_BINARY_DIR}/${java_file_name}-jdoc.java")
+        list(APPEND undocumented_java_files "${java_file}")
+    endif()
+endforeach()
+
+# generate javadoc files
+file(GLOB_RECURSE refman_rst_headers "${CMAKE_CURRENT_SOURCE_DIR}/../*.rst")
+add_custom_command(
+    OUTPUT ${documented_java_files}
+    COMMAND ${PYTHON_EXECUTABLE} "${GEN_JAVADOC}" "${CMAKE_CURRENT_SOURCE_DIR}/src/java" "${CMAKE_CURRENT_BINARY_DIR}" 2>"${CMAKE_CURRENT_BINARY_DIR}/get_javadoc_errors.log"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    DEPENDS ${undocumented_java_files}
+    DEPENDS "${GEN_JAVADOC}"
+    DEPENDS "${RST_PARSER}"
+    DEPENDS ${refman_rst_headers}
+)
+
+# copy generated java files to the final location
+SET(JAVA_OUTPUT_DIR "src/org/opencv")
+
+set(java_files)
+foreach(java_file ${documented_java_files})
+    get_filename_component(java_file_name "${java_file}" NAME)
+    string(REPLACE "-jdoc.java" ".java" java_file_name "${java_file_name}")
+    string(REPLACE "+" "/" java_file_name "${java_file_name}")
+
+    add_custom_command(
+        OUTPUT "${CMAKE_BINARY_DIR}/${JAVA_OUTPUT_DIR}/${java_file_name}"
+        COMMAND ${CMAKE_COMMAND} -E copy "${java_file}" "${CMAKE_BINARY_DIR}/${JAVA_OUTPUT_DIR}/${java_file_name}"
+        DEPENDS "${java_file}"
+        COMMENT "Generating ${JAVA_OUTPUT_DIR}/${java_file_name}"
+        )
+    list(APPEND java_files "${CMAKE_BINARY_DIR}/${JAVA_OUTPUT_DIR}/${java_file_name}")
+    
+    if(ANDROID)
+        get_filename_component(install_subdir "${java_file_name}" PATH)
+        install(FILES "${CMAKE_BINARY_DIR}/${JAVA_OUTPUT_DIR}/${java_file_name}" DESTINATION ${JAVA_OUTPUT_DIR}/${install_subdir} COMPONENT main)
+    endif()
+endforeach()
+
+# custom target for java API
+set(api_target ${target}_api)
+ADD_CUSTOM_TARGET(${api_target} DEPENDS ${java_files})
+
+
+# add opencv_java library
+add_library(${target} SHARED ${handwrittren_h_sources} ${handwrittren_cpp_sources} ${generated_cpp_sources})
+target_link_libraries(${target} ${dependent_libs} ${dependent_extra_libs} ${OPENCV_LINKER_LIBS})
+add_dependencies(${target} ${dependent_extra_libs} ${dependent_libs} ${api_target})
+
+# Additional target properties
+set_target_properties(${target} PROPERTIES
+    OUTPUT_NAME "${target}"
+    ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    INSTALL_NAME_DIR ${OPENCV_LIB_INSTALL_PATH}
+    )
+
+install(TARGETS ${target} LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+
+if(ANDROID)
+    target_link_libraries(${target} jnigraphics)
+
+    # force strip library after build command
+    # because samples and tests will make a copy of library before install
+    ADD_CUSTOM_COMMAND(
+        TARGET ${target}
+        POST_BUILD
+        COMMAND ${CMAKE_STRIP} "${LIBRARY_OUTPUT_PATH}/lib${target}.so"
+        )
+
+    set(lib_proj_files)
+    # library project blank
+    file(GLOB_RECURSE android_lib_project_files "${CMAKE_CURRENT_SOURCE_DIR}/android/*")
+    foreach(file ${android_lib_project_files})
+        if(NOT file MATCHES "\\.svn")
+            file(RELATIVE_PATH file_rel "${CMAKE_CURRENT_SOURCE_DIR}/android/" "${file}")
+            add_custom_command(
+                OUTPUT "${CMAKE_BINARY_DIR}/${file_rel}"
+                COMMAND ${CMAKE_COMMAND} -E copy "${file}" "${CMAKE_BINARY_DIR}/${file_rel}"
+                DEPENDS "${file}"
+                COMMENT "Generating ${file_rel}"
+                )
+            
+            list(APPEND lib_proj_files "${CMAKE_BINARY_DIR}/${file_rel}")
+
+            if(NOT file_rel MATCHES "jni/.+")
+                install(FILES "${CMAKE_BINARY_DIR}/${file_rel}" DESTINATION . COMPONENT main)
+            endif()
+        endif()
+    endforeach()
+
+    # library project jni sources
+    foreach(jni_file ${handwrittren_cpp_sources} ${handwrittren_h_sources} ${generated_cpp_sources})
+        get_filename_component(jni_file_name "${jni_file}" NAME)
+        add_custom_command(
+            OUTPUT "${CMAKE_BINARY_DIR}/jni/${jni_file_name}"
+            COMMAND ${CMAKE_COMMAND} -E copy "${jni_file}" "${CMAKE_BINARY_DIR}/jni/${jni_file_name}"
+            COMMAND ${CMAKE_COMMAND} -E touch "${CMAKE_BINARY_DIR}/jni/${jni_file_name}"
+            DEPENDS "${jni_file}"
+            COMMENT "Generating jni/${jni_file_name}"
+        )
+        list(APPEND lib_proj_files "${CMAKE_BINARY_DIR}/jni/${jni_file_name}")
+    endforeach()    
+    
+    # create Android library project in build folder
+    set(lib_target ${target}_android_library)
+    ADD_CUSTOM_TARGET(${lib_target}
+        COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/res"
+        COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/gen"
+        DEPENDS ${lib_proj_files}
+        )
+    add_dependencies(${lib_target} ${api_target})
+    add_dependencies(${target} ${lib_target})
+
+endif(ANDROID)
+
+#android test project
+if(BUILD_TESTS)
+    add_android_project(opencv_test_java "${CMAKE_CURRENT_SOURCE_DIR}/android_test")
+
+    add_custom_command(
+        TARGET opencv_test_java_android_project POST_BUILD
+        COMMAND ${PYTHON_EXECUTABLE} ${CHECK_TEST_COVERAGE} "${CMAKE_CURRENT_SOURCE_DIR}/android_test/src" "${CMAKE_BINARY_DIR}/src" > "${CMAKE_CURRENT_BINARY_DIR}/tests_coverage.log"
+        )
+endif()
diff --git a/modules/java/android/.classpath b/modules/java/android/.classpath
new file mode 100644
index 0000000000..dd19757ca5
--- /dev/null
+++ b/modules/java/android/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="output" path="cls"/>
+</classpath>
diff --git a/modules/java/android/.project b/modules/java/android/.project
new file mode 100644
index 0000000000..97b71b63ab
--- /dev/null
+++ b/modules/java/android/.project
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>OpenCV-2.3.1</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/modules/java/android/AndroidManifest.xml b/modules/java/android/AndroidManifest.xml
new file mode 100644
index 0000000000..6e3abfd8be
--- /dev/null
+++ b/modules/java/android/AndroidManifest.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv"
+      android:versionCode="1"
+      android:versionName="1.0">
+</manifest> 
diff --git a/android/android-opencv/default.properties b/modules/java/android/default.properties
similarity index 89%
rename from android/android-opencv/default.properties
rename to modules/java/android/default.properties
index 9d135cb85f..863e850239 100644
--- a/android/android-opencv/default.properties
+++ b/modules/java/android/default.properties
@@ -1,11 +1,12 @@
 # This file is automatically generated by Android Tools.
 # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
+#
 # This file must be checked in Version Control Systems.
-# 
+#
 # To customize properties used by the Ant build system use,
 # "build.properties", and override values to adapt the script to your
 # project structure.
 
+android.library=true
 # Project target.
-target=android-7
+target=android-8
diff --git a/modules/java/android/jni/Android.mk b/modules/java/android/jni/Android.mk
new file mode 100644
index 0000000000..72418c893f
--- /dev/null
+++ b/modules/java/android/jni/Android.mk
@@ -0,0 +1,16 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+OPENCV_CAMERA_MODULES := off
+include OpenCV.mk
+
+LOCAL_MODULE    := opencv_java
+
+MY_PREFIX := $(LOCAL_PATH)
+MY_SOURCES := $(wildcard $(MY_PREFIX)/*.cpp)
+LOCAL_SRC_FILES := $(MY_SOURCES:$(MY_PREFIX)%=%)
+
+LOCAL_LDLIBS +=  -llog -ldl -ljnigraphics
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/modules/java/android/jni/Application.mk b/modules/java/android/jni/Application.mk
new file mode 100644
index 0000000000..c7de9c761b
--- /dev/null
+++ b/modules/java/android/jni/Application.mk
@@ -0,0 +1,3 @@
+APP_STL := gnustl_static
+APP_CPPFLAGS := -frtti -fexceptions
+APP_ABI := armeabi-v7a
diff --git a/modules/java/android_test/.classpath b/modules/java/android_test/.classpath
new file mode 100644
index 0000000000..acecb835a9
--- /dev/null
+++ b/modules/java/android_test/.classpath
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="src" path="OpenCV_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/modules/java/android_test/.project b/modules/java/android_test/.project
new file mode 100644
index 0000000000..e47735cab2
--- /dev/null
+++ b/modules/java/android_test/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>OpenCV_JavaAPI_Tests</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_8d28b05d/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/modules/java/android_test/.settings/org.eclipse.jdt.core.prefs b/modules/java/android_test/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/modules/java/android_test/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/modules/java/android_test/AndroidManifest.xml b/modules/java/android_test/AndroidManifest.xml
new file mode 100644
index 0000000000..337afabdc3
--- /dev/null
+++ b/modules/java/android_test/AndroidManifest.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.test"
+      android:versionCode="1"
+      android:versionName="1.0">
+      
+    <uses-sdk android:minSdkVersion="8" />
+    <instrumentation android:targetPackage="org.opencv.test" android:name="OpenCVTestRunner"></instrumentation>
+    
+    <application android:icon="@drawable/icon" android:label="@string/app_name">
+        <uses-library android:name="android.test.runner" />
+    </application>
+    
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
+</manifest>
\ No newline at end of file
diff --git a/modules/java/android_test/default.properties b/modules/java/android_test/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/modules/java/android_test/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/modules/java/android_test/res/drawable/chessboard.jpg b/modules/java/android_test/res/drawable/chessboard.jpg
new file mode 100644
index 0000000000..6ade32006e
Binary files /dev/null and b/modules/java/android_test/res/drawable/chessboard.jpg differ
diff --git a/android/apps/CVCamera/res/drawable-hdpi/icon.png b/modules/java/android_test/res/drawable/icon.png
similarity index 100%
rename from android/apps/CVCamera/res/drawable-hdpi/icon.png
rename to modules/java/android_test/res/drawable/icon.png
diff --git a/modules/java/android_test/res/drawable/lena.jpg b/modules/java/android_test/res/drawable/lena.jpg
new file mode 100644
index 0000000000..f06aa74a57
Binary files /dev/null and b/modules/java/android_test/res/drawable/lena.jpg differ
diff --git a/android/apps/OpenCV_SAMPLE/res/layout/main.xml b/modules/java/android_test/res/layout/main.xml
similarity index 100%
rename from android/apps/OpenCV_SAMPLE/res/layout/main.xml
rename to modules/java/android_test/res/layout/main.xml
diff --git a/modules/java/android_test/res/raw/lbpcascade_frontalface.xml b/modules/java/android_test/res/raw/lbpcascade_frontalface.xml
new file mode 100644
index 0000000000..59850cb9c0
--- /dev/null
+++ b/modules/java/android_test/res/raw/lbpcascade_frontalface.xml
@@ -0,0 +1,1505 @@
+<?xml version="1.0"?>
+<!--
+number of positive samples 3000
+number of negative samples 1500
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier">
+  <stageType>BOOST</stageType>
+  <featureType>LBP</featureType>
+  <height>24</height>
+  <width>24</width>
+  <stageParams>
+    <boostType>GAB</boostType>
+    <minHitRate>0.9950000047683716</minHitRate>
+    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
+    <weightTrimRate>0.9500000000000000</weightTrimRate>
+    <maxDepth>1</maxDepth>
+    <maxWeakCount>100</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>256</maxCatCount></featureParams>
+  <stageNum>20</stageNum>
+  <stages>
+    <!-- stage 0 -->
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>-0.7520892024040222</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
+            -16385 587145899 -24005</internalNodes>
+          <leafValues>
+            -0.6543210148811340 0.8888888955116272</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
+            -193593353 -524289 -1</internalNodes>
+          <leafValues>
+            -0.7739216089248657 0.7278633713722229</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 2 -363936790 -893203669 -1337948010 -136907894
+            1088782736 -134217726 -741544961 -1590337</internalNodes>
+          <leafValues>
+            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
+    <!-- stage 1 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-0.4872078299522400</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 84 2147483647 1946124287 -536870913 2147450879
+            738132490 1061101567 243204619 2147446655</internalNodes>
+          <leafValues>
+            -0.8083735704421997 0.7685696482658386</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
+            -134252545 -268435457 801111999</internalNodes>
+          <leafValues>
+            -0.7698410153388977 0.6592915654182434</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 106 -98110272 1610939566 -285484400 -850010381
+            -189334372 -1671954433 -571026695 -262145</internalNodes>
+          <leafValues>
+            -0.7506558895111084 0.5444605946540833</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
+            -216727745 -69206049</internalNodes>
+          <leafValues>
+            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
+    <!-- stage 2 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-1.1592328548431396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
+            -151016790 -134238549</internalNodes>
+          <leafValues>
+            -0.5601882934570313 0.7743113040924072</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 12 -286003217 183435247 -268994614 -421330945
+            -402686081 1090387966 -286785545 -402653185</internalNodes>
+          <leafValues>
+            -0.6124526262283325 0.6978127956390381</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
+            -50364513 -33619992 -172490753</internalNodes>
+          <leafValues>
+            -0.6114496588706970 0.6537628173828125</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
+            2146926575 -18910642 1095231247</internalNodes>
+          <leafValues>
+            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
+    <!-- stage 3 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.7562355995178223</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
+            2004875127 -250 -150995969</internalNodes>
+          <leafValues>
+            -0.4051094949245453 0.7584033608436585</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
+            -268959873 -2656269 -524289</internalNodes>
+          <leafValues>
+            -0.7388162612915039 0.5340843200683594</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
+            -72478976</internalNodes>
+          <leafValues>
+            -0.6582943797111511 0.5339496731758118</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
+            -990117891 -488975296 -520947741</internalNodes>
+          <leafValues>
+            -0.5981323719024658 0.5323504805564880</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 53 557787431 670265215 -1342193665 -1075892225
+            1998528318 1056964607 -33570977 -1</internalNodes>
+          <leafValues>
+            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
+    <!-- stage 4 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8085358142852783</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
+            -168427659 -16777260 -33554626</internalNodes>
+          <leafValues>
+            -0.5278195738792419 0.6946372389793396</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
+            -39577 -531118985</internalNodes>
+          <leafValues>
+            -0.5206505060195923 0.6329920291900635</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
+            -167903241 -1 -1</internalNodes>
+          <leafValues>
+            -0.7516061067581177 0.4232024252414703</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
+            -1 733886267</internalNodes>
+          <leafValues>
+            -0.7639313936233521 0.4123568832874298</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -85474705 2138828511 -1036436754 817625855
+            1123369029 -58796809 -1013468481 -194513409</internalNodes>
+          <leafValues>
+            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
+    <!-- stage 5 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.5549971461296082</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
+            -21846</internalNodes>
+          <leafValues>
+            -0.3763174116611481 0.7298233509063721</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 6 -805310737 -2098262358 -269504725 682502698
+            2147483519 1740574719 -1090519233 -268472385</internalNodes>
+          <leafValues>
+            -0.5352765917778015 0.5659480094909668</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
+            -50856216 -16849696</internalNodes>
+          <leafValues>
+            -0.5678374171257019 0.4961479902267456</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
+            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
+          <leafValues>
+            -0.5706262588500977 0.4572288393974304</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
+            -36190633 33498198 -151796633</internalNodes>
+          <leafValues>
+            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
+    <!-- stage 6 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8776460289955139</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
+            -101384321 -690225153 -264193</internalNodes>
+          <leafValues>
+            -0.7700348496437073 0.5943940877914429</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
+            -1342767105 -1078198273 -1277955</internalNodes>
+          <leafValues>
+            -0.5043668746948242 0.6151274442672730</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 35 -1067385040 -195758209 -436748425 -134217731
+            -50855988 -129 -1 -1</internalNodes>
+          <leafValues>
+            -0.6808040738105774 0.4667325913906097</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
+            2105014143 -2114244 -17367185</internalNodes>
+          <leafValues>
+            -0.4927591383457184 0.5401885509490967</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
+            -1140949004 -3 -2361356 -739516</internalNodes>
+          <leafValues>
+            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
+    <!-- stage 7 -->
+    <_>
+      <maxWeakCount>6</maxWeakCount>
+      <stageThreshold>-1.1139287948608398</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
+            -335548482 582134442</internalNodes>
+          <leafValues>
+            -0.5307556986808777 0.6258179545402527</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 99 -706937396 -705364068 -540016724 -570495027
+            -570630659 -587857963 -33628164 -35848193</internalNodes>
+          <leafValues>
+            -0.5227634310722351 0.5049746036529541</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
+            1325432815 1954394111 -805306449</internalNodes>
+          <leafValues>
+            -0.4983572661876679 0.5106441378593445</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 111 -282529488 -1558073088 1426018736 -170526448
+            -546832487 -5113037 -34243375 -570427929</internalNodes>
+          <leafValues>
+            -0.4990860521793366 0.5060507059097290</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 92 1016332500 -606301707 915094269 -1080086049
+            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
+          <leafValues>
+            -0.5695009231567383 0.4460467398166657</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 51 -656420166 -15413034 -141599534 -603435836
+            1505950458 -787556946 -79823438 -1326199134</internalNodes>
+          <leafValues>
+            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
+    <!-- stage 8 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.8243625760078430</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
+            -524289 -41943178 -1</internalNodes>
+          <leafValues>
+            -0.4972776770591736 0.6027074456214905</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
+            -32901 -71344315 -29377</internalNodes>
+          <leafValues>
+            -0.4383158981800079 0.5966237187385559</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
+            2076233213 2123118847 801906927</internalNodes>
+          <leafValues>
+            -0.6386105418205261 0.3977999985218048</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
+            1315930109 -696268833 -455082829</internalNodes>
+          <leafValues>
+            -0.5512794256210327 0.4282079637050629</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 73 -521411968 6746762 -1396236286 -2038436114
+            -185612509 57669627 -143132877 -1041235973</internalNodes>
+          <leafValues>
+            -0.6418755054473877 0.3549866080284119</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 126 -478153869 1076028979 -1645895615 1365298272
+            -557859073 -339771473 1442574528 -1058802061</internalNodes>
+          <leafValues>
+            -0.4841901361942291 0.4668019413948059</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
+            1467604861 -2787397 1476263935 -4481349</internalNodes>
+          <leafValues>
+            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
+    <!-- stage 9 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-1.2237116098403931</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
+            1433927541 -268608444 -34865205</internalNodes>
+          <leafValues>
+            -0.2518476545810700 0.7088654041290283</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
+            -8231 -33603327</internalNodes>
+          <leafValues>
+            -0.4303432404994965 0.5283288359642029</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
+            -809512977 1744707583 -41959433 -134758978</internalNodes>
+          <leafValues>
+            -0.4259553551673889 0.5440809130668640</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 34 729753407 -134270989 -1140907329 -235200777
+            658456383 2147467263 -1140900929 -16385</internalNodes>
+          <leafValues>
+            -0.5605589151382446 0.4220733344554901</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 134 -310380553 -420675595 -193005472 -353568129
+            1205338070 -990380036 887604324 -420544526</internalNodes>
+          <leafValues>
+            -0.5192656517028809 0.4399855434894562</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 16 -1427119361 1978920959 -287119734 -487068946
+            114759245 -540578051 -707510259 -671660453</internalNodes>
+          <leafValues>
+            -0.5013077259063721 0.4570254683494568</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 74 -738463762 -889949281 -328301948 -121832450
+            -1142658284 -1863576559 2146417353 -263185</internalNodes>
+          <leafValues>
+            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
+    <!-- stage 10 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.5544230937957764</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
+            -272842924</internalNodes>
+          <leafValues>
+            -0.3949716091156006 0.6082032322883606</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
+            -1212613127 799948719 -4456483</internalNodes>
+          <leafValues>
+            -0.4855885505676270 0.4785369932651520</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 37 784215839 -290015241 536832799 -402984963
+            -1342414991 -838864897 -176769 -268456129</internalNodes>
+          <leafValues>
+            -0.4620285332202911 0.4989669024944305</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
+            -772751172 -73096060 -585322623</internalNodes>
+          <leafValues>
+            -0.6420643329620361 0.3624351918697357</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
+            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
+          <leafValues>
+            -0.4820112884044647 0.4632140696048737</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
+            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
+          <leafValues>
+            -0.4465552568435669 0.5061788558959961</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
+            -1342177297 -268439634 -1464078708</internalNodes>
+          <leafValues>
+            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
+    <!-- stage 11 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.7161560654640198</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
+            -43646987 -1210581153 1195769615</internalNodes>
+          <leafValues>
+            -0.4323809444904327 0.5663768053054810</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 15 -778583572 -612921106 -578775890 -4036478
+            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
+          <leafValues>
+            -0.4588732719421387 0.4547033011913300</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
+            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
+          <leafValues>
+            -0.5218553543090820 0.4111092388629913</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 102 -84148365 -2093417722 -1204850272 564290299
+            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
+          <leafValues>
+            -0.4920000731945038 0.4326725304126740</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
+            1702788383 -144191964 -234882162</internalNodes>
+          <leafValues>
+            -0.4494568109512329 0.4448510706424713</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 59 -857980836 904682741 -1612267521 232279415
+            1550862252 -574825221 -357380888 -4579409</internalNodes>
+          <leafValues>
+            -0.5180826783180237 0.3888972699642181</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
+            -1196072350 -620603549 2137216273</internalNodes>
+          <leafValues>
+            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
+    <!-- stage 12 -->
+    <_>
+      <maxWeakCount>8</maxWeakCount>
+      <stageThreshold>-0.6743940711021423</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 29 -150995201 2071191945 -1302151626 536934335
+            -1059008937 914128709 1147328110 -268369925</internalNodes>
+          <leafValues>
+            -0.1790193915367127 0.6605972051620483</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 128 -134509479 1610575703 -1342177289 1861484541
+            -1107833788 1577058173 -333558568 -136319041</internalNodes>
+          <leafValues>
+            -0.3681024610996246 0.5139749646186829</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
+            779616255 -839568424 -321</internalNodes>
+          <leafValues>
+            -0.3217232525348663 0.6171553134918213</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
+            1275504943 1344390399 -966276889</internalNodes>
+          <leafValues>
+            -0.4373284578323364 0.4358185231685638</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
+            -1684005538 872217086 -1155858277</internalNodes>
+          <leafValues>
+            -0.4404836893081665 0.4601220190525055</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 124 -336593039 1873735591 -822231622 -355795238
+            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
+          <leafValues>
+            -0.4294152259826660 0.4452161788940430</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 54 -834212130 -593694721 -322142257 -364892500
+            -951029539 -302125121 -1615106053 -79249765</internalNodes>
+          <leafValues>
+            -0.3973052501678467 0.4854526817798615</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
+            1988052447 536827383</internalNodes>
+          <leafValues>
+            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
+    <!-- stage 13 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.2042298316955566</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 39 1431368960 -183437936 -537002499 -137497097
+            1560590321 -84611081 -2097193 -513</internalNodes>
+          <leafValues>
+            -0.5905947685241699 0.5101932883262634</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 120 -1645259691 2105491231 2130706431 1458995007
+            -8567536 -42483883 -33780003 -21004417</internalNodes>
+          <leafValues>
+            -0.4449204802513123 0.4490709304809570</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 89 -612381022 -505806938 -362027516 -452985106
+            275854917 1920431639 -12600561 -134221825</internalNodes>
+          <leafValues>
+            -0.4693818688392639 0.4061094820499420</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
+            2000682871 -33604275 -150997129</internalNodes>
+          <leafValues>
+            -0.3600351214408875 0.5056326985359192</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
+            -4755729 -1083162625 -71365637</internalNodes>
+          <leafValues>
+            -0.4459891915321350 0.4132415652275085</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
+            -270209208 -1088293113 -825311232</internalNodes>
+          <leafValues>
+            -0.4466069042682648 0.4135067760944367</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
+            -356831940 -1091125345 -1073796897</internalNodes>
+          <leafValues>
+            -0.3394956290721893 0.5658645033836365</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 75 -276830049 1378714472 -1342181951 757272098
+            1073740607 -282199241 -415761549 170896931</internalNodes>
+          <leafValues>
+            -0.5346512198448181 0.3584479391574860</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 55 -796075825 -123166849 2113667055 -217530421
+            -1107432194 -16385 -806359809 -391188771</internalNodes>
+          <leafValues>
+            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
+    <!-- stage 14 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.8402050137519836</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
+            -1291847681 -68159890 -469829921</internalNodes>
+          <leafValues>
+            -0.2670986354351044 0.6014143228530884</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
+            -1074016265 -840443905 2147221487 -262145</internalNodes>
+          <leafValues>
+            -0.4149844348430634 0.4670888185501099</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 40 1426190596 1899364271 2142731795 -142607505
+            -508232452 -21563393 -41960001 -65</internalNodes>
+          <leafValues>
+            -0.4985891580581665 0.3719584941864014</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 109 -201337965 10543906 -236498096 -746195597
+            1974565825 -15204415 921907633 -190058309</internalNodes>
+          <leafValues>
+            -0.4568729996681213 0.3965812027454376</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 130 -595026732 -656401928 -268649235 -571490699
+            -440600392 -133131 -358810952 -2004088646</internalNodes>
+          <leafValues>
+            -0.4770836830139160 0.3862601518630981</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 66 941674740 -1107882114 1332789109 -67691015
+            -1360463693 -1556612430 -609108546 733546933</internalNodes>
+          <leafValues>
+            -0.4877715110778809 0.3778986334800720</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
+            -1308544889 -532635478 -99042357</internalNodes>
+          <leafValues>
+            -0.3721654713153839 0.4994400143623352</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 133 -655906006 1405502603 -939205164 1884929228
+            -498859222 559417357 -1928559445 -286264385</internalNodes>
+          <leafValues>
+            -0.3934195041656494 0.4769641458988190</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
+            251612987 2013265917 -671232197</internalNodes>
+          <leafValues>
+            -0.4323300719261169 0.4342164099216461</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
+            -1644484728 807009019 1069089930</internalNodes>
+          <leafValues>
+            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
+    <!-- stage 15 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.1974394321441650</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
+            -201348440 -71333206</internalNodes>
+          <leafValues>
+            -0.3310225307941437 0.5624626278877258</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 90 -136842268 -499330741 2015250980 -87107126
+            -641665744 -788524639 -1147864792 -134892563</internalNodes>
+          <leafValues>
+            -0.5266560912132263 0.3704403042793274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 104 -146800880 -1780368555 2111170033 -140904684
+            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
+          <leafValues>
+            -0.4171888828277588 0.4540435671806335</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 85 -832054034 -981663763 -301990281 -578814081
+            -932319000 -1997406723 -33555201 -69206017</internalNodes>
+          <leafValues>
+            -0.4556705355644226 0.3704262077808380</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
+            1112948738 -297319313 1378887291 -139469193</internalNodes>
+          <leafValues>
+            -0.4182529747486115 0.4267231225967407</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 78 -1714382628 -2353704 -112094959 -549613092
+            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
+          <leafValues>
+            -0.3625369668006897 0.4684656262397766</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
+            -260901769 -621461759 -88607770</internalNodes>
+          <leafValues>
+            -0.4742925167083740 0.3689507246017456</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 11 -294654041 -353603585 -1641159686 -50331921
+            -2080899877 1145569279 -143132713 -152044037</internalNodes>
+          <leafValues>
+            -0.3666271567344666 0.4580127298831940</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 32 1887453658 -638545712 -1877976819 -34320972
+            -1071067983 -661345416 -583338277 1060190561</internalNodes>
+          <leafValues>
+            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
+    <!-- stage 16 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.5733128190040588</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 122 -994063296 1088745462 -318837116 -319881377
+            1102566613 1165490103 -121679694 -134744129</internalNodes>
+          <leafValues>
+            -0.4055117964744568 0.5487945079803467</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
+            -20593 -20505 -1561401854</internalNodes>
+          <leafValues>
+            -0.3787897229194641 0.4532003402709961</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 58 -1335245632 1968917183 1940861695 536816369
+            -1226071367 -570908176 457026619 1000020667</internalNodes>
+          <leafValues>
+            -0.4258328974246979 0.4202791750431061</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
+            -608879292 -805306691 -269304244 -17840167</internalNodes>
+          <leafValues>
+            -0.4561023116111755 0.4002747833728790</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
+            -1090552065 -772846337 -570464322</internalNodes>
+          <leafValues>
+            -0.4314672648906708 0.4086346626281738</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 127 -536896021 1080817663 -738234288 -965478709
+            -2082767969 1290855887 1993822934 -990381609</internalNodes>
+          <leafValues>
+            -0.4174543321132660 0.4249868988990784</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
+            621166734 1086506807 1473768907</internalNodes>
+          <leafValues>
+            -0.4321364760398865 0.4090838730335236</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 79 -68895696 -67107736 -1414315879 -841676168
+            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
+          <leafValues>
+            -0.5018386244773865 0.3702533841133118</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
+            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
+          <leafValues>
+            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
+    <!-- stage 17 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.4892596900463104</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
+            2002237273 -273154752 1937223539</internalNodes>
+          <leafValues>
+            -0.2448196411132813 0.5689709186553955</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 62 1179423888 -78064940 -611839555 -539167899
+            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
+          <leafValues>
+            -0.4633283913135529 0.3587929606437683</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
+            -1334349961 -547662981 -135796924</internalNodes>
+          <leafValues>
+            -0.3731099069118500 0.4290455579757690</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 77 341863476 403702016 -550588417 1600194541
+            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
+          <leafValues>
+            -0.3658909499645233 0.4556473195552826</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 22 -586880702 -204831512 -100644596 -39319550
+            -1191150794 705692513 457203315 -75806957</internalNodes>
+          <leafValues>
+            -0.5214384198188782 0.3221037387847900</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 72 -416546870 545911370 -673716192 -775559454
+            -264113598 139424 -183369982 -204474641</internalNodes>
+          <leafValues>
+            -0.4289036989212036 0.4004956185817719</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
+            1348491006 -60710713 -1109853489 -633909413</internalNodes>
+          <leafValues>
+            -0.4621542394161224 0.3832748532295227</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
+            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
+          <leafValues>
+            -0.3711548447608948 0.4612701535224915</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
+            -74633006 1871559083 1057955850</internalNodes>
+          <leafValues>
+            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
+    <!-- stage 18 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.5911940932273865</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
+            -74153752 -90653988 -1074263896</internalNodes>
+          <leafValues>
+            -0.2592592537403107 0.5873016119003296</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
+            1157103471 2097133565 -2097169</internalNodes>
+          <leafValues>
+            -0.3801195919513702 0.4718827307224274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
+            -866124467 -318782328 -1392509185</internalNodes>
+          <leafValues>
+            -0.3509117066860199 0.5094807147979736</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
+            -8406341 -67663041</internalNodes>
+          <leafValues>
+            -0.4068757295608521 0.4130136370658875</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
+            -447742449 1354229504 -261884429</internalNodes>
+          <leafValues>
+            -0.4557141065597534 0.3539792001247406</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 100 -225319378 -251682065 -492783986 -792341777
+            -1287261695 1393643841 -11274182 -213909521</internalNodes>
+          <leafValues>
+            -0.4117803275585175 0.4118592441082001</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 63 -382220122 -2002072729 -51404800 -371201558
+            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
+          <leafValues>
+            -0.4008397758007050 0.4034757018089294</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 101 -627353764 -48295149 1581203952 -436258614
+            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
+          <leafValues>
+            -0.5694189667701721 0.2964762747287750</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
+            -574619739 -994397789 -1648362021</internalNodes>
+          <leafValues>
+            -0.3195341229438782 0.5294018983840942</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 92 -348343812 -1078389516 1717960437 364735981
+            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
+          <leafValues>
+            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
+    <!-- stage 19 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.7612916231155396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
+            -453637880 1435470000 -1077438561</internalNodes>
+          <leafValues>
+            -0.4204545319080353 0.5165745615959168</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 131 -67110925 14874979 -142633168 -1338923040
+            2046713291 -2067933195 1473503712 -789579837</internalNodes>
+          <leafValues>
+            -0.3762553930282593 0.4075302779674530</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
+            -1073813756 -538971154 -355523038</internalNodes>
+          <leafValues>
+            -0.4253497421741486 0.3728055357933044</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
+            1994225489 -973738098 -203424005</internalNodes>
+          <leafValues>
+            -0.3601998090744019 0.4563256204128265</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 115 -261031688 -1330369299 -641860609 1029570301
+            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
+          <leafValues>
+            -0.4034293889999390 0.4160816967487335</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
+            -19869715 -1920939864 -1279457063</internalNodes>
+          <leafValues>
+            -0.3620899617671967 0.4594142735004425</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 36 -626275097 -615256993 1651946018 805366393
+            2016559730 -430780849 -799868165 -16580645</internalNodes>
+          <leafValues>
+            -0.3903816640377045 0.4381459355354309</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
+            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
+          <leafValues>
+            -0.3591445386409760 0.4624078869819641</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
+            -275513546 648167355 -1145357350</internalNodes>
+          <leafValues>
+            -0.4297670423984528 0.4023293554782867</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 107 -546318240 -1628569602 -163577944 -537002306
+            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
+          <leafValues>
+            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rect>
+        0 0 3 5</rect></_>
+    <_>
+      <rect>
+        0 0 4 2</rect></_>
+    <_>
+      <rect>
+        0 0 6 3</rect></_>
+    <_>
+      <rect>
+        0 1 2 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 7</rect></_>
+    <_>
+      <rect>
+        0 4 3 3</rect></_>
+    <_>
+      <rect>
+        0 11 3 4</rect></_>
+    <_>
+      <rect>
+        0 12 8 4</rect></_>
+    <_>
+      <rect>
+        0 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 0 5 3</rect></_>
+    <_>
+      <rect>
+        1 1 2 2</rect></_>
+    <_>
+      <rect>
+        1 3 3 1</rect></_>
+    <_>
+      <rect>
+        1 7 4 4</rect></_>
+    <_>
+      <rect>
+        1 12 2 2</rect></_>
+    <_>
+      <rect>
+        1 13 4 1</rect></_>
+    <_>
+      <rect>
+        1 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 17 3 2</rect></_>
+    <_>
+      <rect>
+        2 0 2 3</rect></_>
+    <_>
+      <rect>
+        2 1 2 2</rect></_>
+    <_>
+      <rect>
+        2 2 4 6</rect></_>
+    <_>
+      <rect>
+        2 3 4 4</rect></_>
+    <_>
+      <rect>
+        2 7 2 1</rect></_>
+    <_>
+      <rect>
+        2 11 2 3</rect></_>
+    <_>
+      <rect>
+        2 17 3 2</rect></_>
+    <_>
+      <rect>
+        3 0 2 2</rect></_>
+    <_>
+      <rect>
+        3 1 7 3</rect></_>
+    <_>
+      <rect>
+        3 7 2 1</rect></_>
+    <_>
+      <rect>
+        3 7 2 4</rect></_>
+    <_>
+      <rect>
+        3 18 2 2</rect></_>
+    <_>
+      <rect>
+        4 0 2 3</rect></_>
+    <_>
+      <rect>
+        4 3 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 5</rect></_>
+    <_>
+      <rect>
+        4 7 5 2</rect></_>
+    <_>
+      <rect>
+        4 8 4 3</rect></_>
+    <_>
+      <rect>
+        4 18 2 2</rect></_>
+    <_>
+      <rect>
+        5 0 2 2</rect></_>
+    <_>
+      <rect>
+        5 3 4 4</rect></_>
+    <_>
+      <rect>
+        5 6 2 5</rect></_>
+    <_>
+      <rect>
+        5 9 2 2</rect></_>
+    <_>
+      <rect>
+        5 10 2 2</rect></_>
+    <_>
+      <rect>
+        6 3 4 4</rect></_>
+    <_>
+      <rect>
+        6 4 4 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 5</rect></_>
+    <_>
+      <rect>
+        6 5 4 3</rect></_>
+    <_>
+      <rect>
+        6 6 4 2</rect></_>
+    <_>
+      <rect>
+        6 6 4 4</rect></_>
+    <_>
+      <rect>
+        6 18 1 2</rect></_>
+    <_>
+      <rect>
+        6 21 2 1</rect></_>
+    <_>
+      <rect>
+        7 0 3 7</rect></_>
+    <_>
+      <rect>
+        7 4 2 3</rect></_>
+    <_>
+      <rect>
+        7 9 5 1</rect></_>
+    <_>
+      <rect>
+        7 21 2 1</rect></_>
+    <_>
+      <rect>
+        8 0 1 4</rect></_>
+    <_>
+      <rect>
+        8 5 2 2</rect></_>
+    <_>
+      <rect>
+        8 5 3 2</rect></_>
+    <_>
+      <rect>
+        8 17 3 1</rect></_>
+    <_>
+      <rect>
+        8 18 1 2</rect></_>
+    <_>
+      <rect>
+        9 0 5 3</rect></_>
+    <_>
+      <rect>
+        9 2 2 6</rect></_>
+    <_>
+      <rect>
+        9 5 1 1</rect></_>
+    <_>
+      <rect>
+        9 11 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 2 1</rect></_>
+    <_>
+      <rect>
+        9 17 1 1</rect></_>
+    <_>
+      <rect>
+        9 18 1 1</rect></_>
+    <_>
+      <rect>
+        10 5 1 2</rect></_>
+    <_>
+      <rect>
+        10 5 3 3</rect></_>
+    <_>
+      <rect>
+        10 7 1 5</rect></_>
+    <_>
+      <rect>
+        10 8 1 1</rect></_>
+    <_>
+      <rect>
+        10 9 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 2</rect></_>
+    <_>
+      <rect>
+        10 14 3 3</rect></_>
+    <_>
+      <rect>
+        10 15 1 1</rect></_>
+    <_>
+      <rect>
+        10 15 2 1</rect></_>
+    <_>
+      <rect>
+        10 16 1 1</rect></_>
+    <_>
+      <rect>
+        10 16 2 1</rect></_>
+    <_>
+      <rect>
+        10 17 1 1</rect></_>
+    <_>
+      <rect>
+        10 21 1 1</rect></_>
+    <_>
+      <rect>
+        11 3 2 2</rect></_>
+    <_>
+      <rect>
+        11 5 1 2</rect></_>
+    <_>
+      <rect>
+        11 5 3 3</rect></_>
+    <_>
+      <rect>
+        11 5 4 6</rect></_>
+    <_>
+      <rect>
+        11 6 1 1</rect></_>
+    <_>
+      <rect>
+        11 7 2 2</rect></_>
+    <_>
+      <rect>
+        11 8 1 2</rect></_>
+    <_>
+      <rect>
+        11 10 1 1</rect></_>
+    <_>
+      <rect>
+        11 10 1 2</rect></_>
+    <_>
+      <rect>
+        11 15 1 1</rect></_>
+    <_>
+      <rect>
+        11 17 1 1</rect></_>
+    <_>
+      <rect>
+        11 18 1 1</rect></_>
+    <_>
+      <rect>
+        12 0 2 2</rect></_>
+    <_>
+      <rect>
+        12 1 2 5</rect></_>
+    <_>
+      <rect>
+        12 2 4 1</rect></_>
+    <_>
+      <rect>
+        12 3 1 3</rect></_>
+    <_>
+      <rect>
+        12 7 3 4</rect></_>
+    <_>
+      <rect>
+        12 10 3 2</rect></_>
+    <_>
+      <rect>
+        12 11 1 1</rect></_>
+    <_>
+      <rect>
+        12 12 3 2</rect></_>
+    <_>
+      <rect>
+        12 14 4 3</rect></_>
+    <_>
+      <rect>
+        12 17 1 1</rect></_>
+    <_>
+      <rect>
+        12 21 2 1</rect></_>
+    <_>
+      <rect>
+        13 6 2 5</rect></_>
+    <_>
+      <rect>
+        13 7 3 5</rect></_>
+    <_>
+      <rect>
+        13 11 3 2</rect></_>
+    <_>
+      <rect>
+        13 17 2 2</rect></_>
+    <_>
+      <rect>
+        13 17 3 2</rect></_>
+    <_>
+      <rect>
+        13 18 1 2</rect></_>
+    <_>
+      <rect>
+        13 18 2 2</rect></_>
+    <_>
+      <rect>
+        14 0 2 2</rect></_>
+    <_>
+      <rect>
+        14 1 1 3</rect></_>
+    <_>
+      <rect>
+        14 2 3 2</rect></_>
+    <_>
+      <rect>
+        14 7 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 3 3</rect></_>
+    <_>
+      <rect>
+        14 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 3</rect></_>
+    <_>
+      <rect>
+        15 4 3 2</rect></_>
+    <_>
+      <rect>
+        15 4 3 6</rect></_>
+    <_>
+      <rect>
+        15 6 3 2</rect></_>
+    <_>
+      <rect>
+        15 11 3 4</rect></_>
+    <_>
+      <rect>
+        15 13 3 2</rect></_>
+    <_>
+      <rect>
+        15 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 17 3 2</rect></_>
+    <_>
+      <rect>
+        16 1 2 3</rect></_>
+    <_>
+      <rect>
+        16 3 2 4</rect></_>
+    <_>
+      <rect>
+        16 6 1 1</rect></_>
+    <_>
+      <rect>
+        16 16 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 5</rect></_>
+    <_>
+      <rect>
+        17 12 2 2</rect></_>
+    <_>
+      <rect>
+        18 0 2 2</rect></_></features></cascade>
+</opencv_storage>
diff --git a/modules/java/android_test/res/values/strings.xml b/modules/java/android_test/res/values/strings.xml
new file mode 100644
index 0000000000..634387dc9d
--- /dev/null
+++ b/modules/java/android_test/res/values/strings.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="hello">Hello World!</string>
+    <string name="app_name">OpenCV_JavaAPI_Tests</string>
+</resources>
diff --git a/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java b/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java
new file mode 100644
index 0000000000..191f5ee34e
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java
@@ -0,0 +1,410 @@
+package org.opencv.test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.highgui.Highgui;
+
+public class OpenCVTestCase extends TestCase {
+
+    protected static final int matSize = 10;
+    protected static final double EPS = 0.001;
+    protected static final double weakEPS = 0.5;
+
+    protected Mat dst;
+    protected Mat truth;
+
+    protected Scalar colorBlack;
+    protected Scalar colorWhite;
+
+    // Naming notation: <channels info>_[depth]_[dimensions]_value
+    // examples: gray0 - single channel 8U 2d Mat filled with 0
+    // grayRnd - single channel 8U 2d Mat filled with random numbers
+    // gray0_32f_1d
+
+    // TODO: OpenCVTestCase refactorings
+    // - rename matrices
+    // - create methods gray0() and create src1 explicitly
+    // - create some masks
+    // - use truth member everywhere - remove truth from base class - each test
+    // fixture should use own truth filed
+
+    protected Mat gray0;
+    protected Mat gray1;
+    protected Mat gray2;
+    protected Mat gray3;
+    protected Mat gray9;
+    protected Mat gray127;
+    protected Mat gray128;
+    protected Mat gray255;
+    protected Mat grayRnd;
+
+    protected Mat gray_16u_256;
+    protected Mat gray_16s_1024;
+
+    protected Mat gray0_32f;
+    protected Mat gray1_32f;
+    protected Mat gray3_32f;
+    protected Mat gray9_32f;
+    protected Mat gray255_32f;
+    protected Mat grayE_32f;
+    protected Mat grayRnd_32f;
+
+    protected Mat gray0_32f_1d;
+
+    protected Mat gray0_64f;
+    protected Mat gray0_64f_1d;
+
+    protected Mat rgba0;
+    protected Mat rgba128;
+
+    protected Mat rgbLena;
+    protected Mat grayChess;
+
+    protected Mat v1;
+    protected Mat v2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        dst = new Mat();
+        assertTrue(dst.empty());
+        truth = null;
+
+        colorBlack = new Scalar(0);
+        colorWhite = new Scalar(255, 255, 255);
+
+        gray0 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(0));
+        gray1 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(1));
+        gray2 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(2));
+        gray3 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(3));
+        gray9 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(9));
+        gray127 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(127));
+        gray128 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(128));
+        gray255 = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+
+        grayRnd = new Mat(matSize, matSize, CvType.CV_8U);
+        Core.randu(grayRnd, 0, 256);
+
+        gray_16u_256 = new Mat(matSize, matSize, CvType.CV_16U, new Scalar(256));
+        gray_16s_1024 = new Mat(matSize, matSize, CvType.CV_16S, new Scalar(1024));
+
+        gray0_32f = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(0.0));
+        gray1_32f = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(1.0));
+        gray3_32f = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(3.0));
+        gray9_32f = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(9.0));
+        gray255_32f = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(255.0));
+        grayE_32f = new Mat(matSize, matSize, CvType.CV_32F);
+        grayE_32f = Mat.eye(matSize, matSize, CvType.CV_32FC1);
+        grayRnd_32f = new Mat(matSize, matSize, CvType.CV_32F);
+        Core.randu(grayRnd_32f, 0, 256);
+
+        gray0_64f = new Mat(matSize, matSize, CvType.CV_64F, new Scalar(0.0));
+
+        gray0_32f_1d = new Mat(1, matSize, CvType.CV_32F, new Scalar(0.0));
+        gray0_64f_1d = new Mat(1, matSize, CvType.CV_64F, new Scalar(0.0));
+
+        rgba0 = new Mat(matSize, matSize, CvType.CV_8UC4, Scalar.all(0));
+        rgba128 = new Mat(matSize, matSize, CvType.CV_8UC4, Scalar.all(128));
+
+        rgbLena = Highgui.imread(OpenCVTestRunner.LENA_PATH);
+        grayChess = Highgui.imread(OpenCVTestRunner.CHESS_PATH, 0);
+
+        v1 = new Mat(1, 3, CvType.CV_32F);
+        v1.put(0, 0, 1.0, 3.0, 2.0);
+        v2 = new Mat(1, 3, CvType.CV_32F);
+        v2.put(0, 0, 2.0, 1.0, 3.0);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+
+        gray0.release();
+        gray1.release();
+        gray2.release();
+        gray3.release();
+        gray9.release();
+        gray127.release();
+        gray128.release();
+        gray255.release();
+        gray_16u_256.release();
+        gray_16s_1024.release();
+        grayRnd.release();
+        gray0_32f.release();
+        gray1_32f.release();
+        gray3_32f.release();
+        gray9_32f.release();
+        gray255_32f.release();
+        grayE_32f.release();
+        grayE_32f.release();
+        grayRnd_32f.release();
+        gray0_32f_1d.release();
+        gray0_64f.release();
+        gray0_64f_1d.release();
+        rgba0.release();
+        rgba128.release();
+        rgbLena.release();
+        grayChess.release();
+        v1.release();
+        v2.release();
+
+        super.tearDown();
+    }
+
+    protected Mat getMat(int type, double... vals)
+    {
+        return new Mat(matSize, matSize, type, new Scalar(vals));
+    }
+
+    protected Mat makeMask(Mat m, double... vals)
+    {
+        m.submat(0, m.rows(), 0, m.cols() / 2).setTo(new Scalar(vals));
+        return m;
+    }
+
+    public static <E extends Number> void assertListEquals(List<E> list1, List<E> list2) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        if (!list1.isEmpty())
+        {
+            if (list1.get(0) instanceof Float || list1.get(0) instanceof Double)
+                throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertEquals(list1.get(i), list2.get(i));
+    }
+
+    public static <E extends Number> void assertListEquals(List<E> list1, List<E> list2, double epsilon) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertTrue(Math.abs(list1.get(i).doubleValue() - list2.get(i).doubleValue()) <= epsilon);
+    }
+
+    public static void assertListMatEquals(List<Mat> list1, List<Mat> list2, double epsilon) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertMatEqual(list1.get(i), list2.get(i), epsilon);
+    }
+
+    public static void assertListPointEquals(List<Point> list1, List<Point> list2, double epsilon) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertPointEquals(list1.get(i), list2.get(i), epsilon);
+    }
+
+    public static void assertListPoint3Equals(List<Point3> list1, List<Point3> list2, double epsilon) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertPoint3Equals(list1.get(i), list2.get(i), epsilon);
+    }
+
+    public static void assertListRectEquals(List<Rect> list1, List<Rect> list2) {
+        if (list1.size() != list2.size()) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (int i = 0; i < list1.size(); i++)
+            assertRectEquals(list1.get(i), list2.get(i));
+    }
+
+    public static void assertRectEquals(Rect expected, Rect actual) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertEquals(msg, expected.x, actual.x);
+        assertEquals(msg, expected.y, actual.y);
+        assertEquals(msg, expected.width, actual.width);
+        assertEquals(msg, expected.height, actual.height);
+    }
+
+    public static void assertMatEqual(Mat m1, Mat m2) {
+        compareMats(m1, m2, true);
+    }
+
+    public static void assertMatNotEqual(Mat m1, Mat m2) {
+        compareMats(m1, m2, false);
+    }
+
+    public static void assertMatEqual(Mat expected, Mat actual, double eps) {
+        compareMats(expected, actual, eps, true);
+    }
+
+    public static void assertMatNotEqual(Mat expected, Mat actual, double eps) {
+        compareMats(expected, actual, eps, false);
+    }
+
+    public static void assertKeyPointEqual(KeyPoint expected, KeyPoint actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertTrue(msg, Math.hypot(expected.pt.x - actual.pt.x, expected.pt.y - actual.pt.y) < eps);
+        assertTrue(msg, Math.abs(expected.size - actual.size) < eps);
+        assertTrue(msg, Math.abs(expected.angle - actual.angle) < eps);
+        assertTrue(msg, Math.abs(expected.response - actual.response) < eps);
+        assertEquals(msg, expected.octave, actual.octave);
+        assertEquals(msg, expected.class_id, actual.class_id);
+    }
+
+    public static void assertListKeyPointEquals(List<KeyPoint> expected, List<KeyPoint> actual, double epsilon) {
+        assertEquals(expected.size(), actual.size());
+        for (int i = 0; i < expected.size(); i++)
+            assertKeyPointEqual(expected.get(i), actual.get(i), epsilon);
+    }
+
+    public static void assertDMatchEqual(DMatch expected, DMatch actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertEquals(msg, expected.queryIdx, actual.queryIdx);
+        assertEquals(msg, expected.trainIdx, actual.trainIdx);
+        assertEquals(msg, expected.imgIdx, actual.imgIdx);
+        assertTrue(msg, Math.abs(expected.distance - actual.distance) < eps);
+    }
+
+    public static void assertScalarEqual(Scalar expected, Scalar actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertTrue(msg, Math.abs(expected.val[0] - actual.val[0]) < eps);
+        assertTrue(msg, Math.abs(expected.val[1] - actual.val[1]) < eps);
+        assertTrue(msg, Math.abs(expected.val[2] - actual.val[2]) < eps);
+        assertTrue(msg, Math.abs(expected.val[3] - actual.val[3]) < eps);
+    }
+
+    public static void assertListDMatchEquals(List<DMatch> expected, List<DMatch> actual, double epsilon) {
+        assertEquals(expected.size(), actual.size());
+        for (int i = 0; i < expected.size(); i++)
+            assertDMatchEqual(expected.get(i), actual.get(i), epsilon);
+    }
+
+    public static void assertPointEquals(Point expected, Point actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertEquals(msg, expected.x, actual.x, eps);
+        assertEquals(msg, expected.y, actual.y, eps);
+    }
+
+    public static void assertSizeEquals(Size expected, Size actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertEquals(msg, expected.width, actual.width, eps);
+        assertEquals(msg, expected.height, actual.height, eps);
+    }
+
+    public static void assertPoint3Equals(Point3 expected, Point3 actual, double eps) {
+        String msg = "expected:<" + expected + "> but was:<" + actual + ">";
+        assertEquals(msg, expected.x, actual.x, eps);
+        assertEquals(msg, expected.y, actual.y, eps);
+        assertEquals(msg, expected.z, actual.z, eps);
+    }
+
+    static private void compareMats(Mat expected, Mat actual, boolean isEqualityMeasured) {
+        if (expected.type() != actual.type() || expected.cols() != actual.cols() || expected.rows() != actual.rows()) {
+            throw new UnsupportedOperationException("Can not compare " + expected + " and " + actual);
+        }
+
+        if (expected.depth() == CvType.CV_32F || expected.depth() == CvType.CV_64F) {
+            if (isEqualityMeasured)
+                throw new UnsupportedOperationException(
+                        "Floating-point Mats must not be checked for exact match. Use assertMatEqual(Mat expected, Mat actual, double eps) instead.");
+            else
+                throw new UnsupportedOperationException(
+                        "Floating-point Mats must not be checked for exact match. Use assertMatNotEqual(Mat expected, Mat actual, double eps) instead.");
+        }
+
+        Mat diff = new Mat();
+        Core.absdiff(expected, actual, diff);
+        Mat reshaped = diff.reshape(1);
+        int mistakes = Core.countNonZero(reshaped);
+
+        reshaped.release();
+        diff.release();
+
+        if (isEqualityMeasured)
+            assertTrue("Mats are different in " + mistakes + " points", 0 == mistakes);
+        else
+            assertFalse("Mats are equal", 0 == mistakes);
+    }
+
+    static private void compareMats(Mat expected, Mat actual, double eps, boolean isEqualityMeasured) {
+        if (expected.type() != actual.type() || expected.cols() != actual.cols() || expected.rows() != actual.rows()) {
+            throw new UnsupportedOperationException("Can not compare " + expected + " and " + actual);
+        }
+
+        Mat diff = new Mat();
+        Core.absdiff(expected, actual, diff);
+
+        if (isEqualityMeasured)
+            assertTrue("Max difference between expected and actiual Mats is bigger than " + eps,
+                    Core.checkRange(diff, true, new Point(), 0.0, eps));
+        else
+            assertFalse("Max difference between expected and actiual Mats is less than " + eps,
+                    Core.checkRange(diff, true, new Point(), 0.0, eps));
+    }
+
+    protected static String readFile(String path) {
+        FileInputStream stream = null;
+        try {
+            stream = new FileInputStream(new File(path));
+            FileChannel fc = stream.getChannel();
+            MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0,
+                    fc.size());
+            return Charset.defaultCharset().decode(bb).toString();
+        } catch (IOException e) {
+            OpenCVTestRunner.Log("Failed to read file \"" + path
+                    + "\". Exception is thrown: " + e);
+            return null;
+        } finally {
+            if (stream != null)
+                try {
+                    stream.close();
+                } catch (IOException e) {
+                    OpenCVTestRunner.Log("Exception is thrown: " + e);
+                }
+        }
+    }
+
+    protected static void writeFile(String path, String content) {
+        FileOutputStream stream = null;
+        try {
+            stream = new FileOutputStream(new File(path));
+            FileChannel fc = stream.getChannel();
+            fc.write(Charset.defaultCharset().encode(content));
+        } catch (IOException e) {
+            OpenCVTestRunner.Log("Failed to write file \"" + path
+                    + "\". Exception is thrown: " + e);
+        } finally {
+            if (stream != null)
+                try {
+                    stream.close();
+                } catch (IOException e) {
+                    OpenCVTestRunner.Log("Exception is thrown: " + e);
+                }
+        }
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/OpenCVTestRunner.java b/modules/java/android_test/src/org/opencv/test/OpenCVTestRunner.java
new file mode 100644
index 0000000000..0ea89a41a7
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/OpenCVTestRunner.java
@@ -0,0 +1,81 @@
+package org.opencv.test;
+
+import android.content.Context;
+import android.test.AndroidTestRunner;
+import android.test.InstrumentationTestRunner;
+import android.util.Log;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Mat;
+
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * This only class is Android specific.
+ * 
+ * @see <a href="http://opencv.itseez.com">OpenCV</a>
+ */
+
+public class OpenCVTestRunner extends InstrumentationTestRunner {
+
+    public static String LENA_PATH;
+    public static String CHESS_PATH;
+    public static String LBPCASCADE_FRONTALFACE_PATH;
+    public static Context context;
+
+    private AndroidTestRunner androidTestRunner;
+    private static String TAG = "opencv_test_java";
+
+    public static String getTempFileName(String extension)
+    {
+        File cache = context.getCacheDir();
+        if (!extension.startsWith("."))
+            extension = "." + extension;
+        try {
+            File tmp = File.createTempFile("OpenCV", extension, cache);
+            String path = tmp.getAbsolutePath();
+            tmp.delete();
+            return path;
+        } catch (IOException e) {
+            Log("Failed to get temp file name. Exception is thrown: " + e);
+        }
+        return null;
+    }
+
+    static public void Log(String message) {
+        Log.e(TAG, message);
+    }
+
+    static public void Log(Mat m) {
+        Log.e(TAG, m + "\n " + m.dump());
+    }
+
+    @Override
+    public void onStart() {
+        context = getContext();
+        LENA_PATH = Utils.exportResource(context, R.drawable.lena);
+        CHESS_PATH = Utils.exportResource(context, R.drawable.chessboard);
+        LBPCASCADE_FRONTALFACE_PATH = Utils.exportResource(context, R.raw.lbpcascade_frontalface);
+
+        /*
+         * The original idea about test order randomization is from
+         * marek.defecinski blog.
+         */
+        // List<TestCase> testCases = androidTestRunner.getTestCases();
+        // Collections.shuffle(testCases); //shuffle the tests order
+
+        super.onStart();
+    }
+
+    @Override
+    protected AndroidTestRunner getAndroidTestRunner() {
+        androidTestRunner = super.getAndroidTestRunner();
+        return androidTestRunner;
+    }
+
+    public static String getOutputFileName(String name)
+    {
+        return context.getExternalFilesDir(null).getAbsolutePath() + File.separatorChar + name;
+    }
+}
diff --git a/modules/java/android_test/src/org/opencv/test/android/UtilsTest.java b/modules/java/android_test/src/org/opencv/test/android/UtilsTest.java
new file mode 100644
index 0000000000..082e26caea
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/android/UtilsTest.java
@@ -0,0 +1,31 @@
+package org.opencv.test.android;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class UtilsTest extends OpenCVTestCase {
+
+    public void testBitmapToMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testExportResourceContextInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testExportResourceContextIntString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadResourceContextInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadResourceContextIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatToBitmap() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java b/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java
new file mode 100644
index 0000000000..9c917be4eb
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java
@@ -0,0 +1,580 @@
+package org.opencv.test.calib3d;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class Calib3dTest extends OpenCVTestCase {
+
+    public void testCalibrateCameraListOfMatListOfMatSizeMatMatListOfMatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalibrateCameraListOfMatListOfMatSizeMatMatListOfMatListOfMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalibrationMatrixValues() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMat() {
+        Mat rvec1 = new Mat(3, 1, CvType.CV_32F);
+        rvec1.put(0, 0, 0.5302828, 0.19925919, 0.40105945);
+        Mat tvec1 = new Mat(3, 1, CvType.CV_32F);
+        tvec1.put(0, 0, 0.81438506, 0.43713298, 0.2487897);
+        Mat rvec2 = new Mat(3, 1, CvType.CV_32F);
+        rvec2.put(0, 0, 0.77310503, 0.76209372, 0.30779448);
+        Mat tvec2 = new Mat(3, 1, CvType.CV_32F);
+        tvec2.put(0, 0, 0.70243168, 0.4784472, 0.79219002);
+
+        Mat rvec3 = new Mat();
+        Mat tvec3 = new Mat();
+
+        Mat outRvec = new Mat(3, 1, CvType.CV_32F);
+        outRvec.put(0, 0, 1.418641, 0.88665926, 0.56020796);
+        Mat outTvec = new Mat(3, 1, CvType.CV_32F);
+        outTvec.put(0, 0, 1.4560841, 1.0680628, 0.81598103);
+
+        Calib3d.composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3);
+
+        assertMatEqual(outRvec, rvec3, EPS);
+        assertMatEqual(outTvec, tvec3, EPS);
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComposeRTMatMatMatMatMatMatMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+        // Mat dr3dr1;
+        // Mat dr3dt1;
+        // Mat dr3dr2;
+        // Mat dr3dt2;
+        // Mat dt3dr1;
+        // Mat dt3dt1;
+        // Mat dt3dr2;
+        // Mat dt3dt2;
+        // , dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2);
+        // [0.97031879, -0.091774099, 0.38594806;
+        // 0.15181915, 0.98091727, -0.44186208;
+        // -0.39509675, 0.43839464, 0.93872648]
+        // [0, 0, 0;
+        // 0, 0, 0;
+        // 0, 0, 0]
+        // [1.0117353, 0.16348237, -0.083180845;
+        // -0.1980398, 1.006078, 0.30299222;
+        // 0.075766489, -0.32784501, 1.0163091]
+        // [0, 0, 0;
+        // 0, 0, 0;
+        // 0, 0, 0]
+        // [0, 0, 0;
+        // 0, 0, 0;
+        // 0, 0, 0]
+        // [0.69658804, 0.018115902, 0.7172426;
+        // 0.51114357, 0.68899536, -0.51382649;
+        // -0.50348526, 0.72453934, 0.47068608]
+        // [0.18536358, -0.20515044, -0.48834875;
+        // -0.25120571, 0.29043972, 0.60573936;
+        // 0.35370794, -0.69923931, 0.45781645]
+        // [1, 0, 0;
+        // 0, 1, 0;
+        // 0, 0, 1]
+    }
+
+    public void testConvertPointsFromHomogeneous() {
+        fail("Not yet implemented");
+    }
+
+    public void testConvertPointsToHomogeneous() {
+        fail("Not yet implemented");
+    }
+
+    public void testDecomposeProjectionMatrixMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDecomposeProjectionMatrixMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDecomposeProjectionMatrixMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDecomposeProjectionMatrixMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDecomposeProjectionMatrixMatMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawChessboardCorners() {
+        fail("Not yet implemented");
+    }
+
+    public void testEstimateAffine3DMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEstimateAffine3DMatMatMatMatDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testEstimateAffine3DMatMatMatMatDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testFilterSpecklesMatDoubleIntDouble() {
+        gray_16s_1024.copyTo(dst);
+        Point center = new Point(gray_16s_1024.rows() / 2., gray_16s_1024.cols() / 2.);
+        Core.circle(dst, center, 1, Scalar.all(4096));
+
+        assertMatNotEqual(gray_16s_1024, dst);
+        Calib3d.filterSpeckles(dst, 1024.0, 100, 0.);
+        assertMatEqual(gray_16s_1024, dst);
+    }
+
+    public void testFilterSpecklesMatDoubleIntDoubleMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindChessboardCornersMatSizeMat() {
+        Size patternSize = new Size(9, 6);
+        Calib3d.findChessboardCorners(grayChess, patternSize, dst);
+        assertTrue(!dst.empty());
+    }
+
+    public void testFindChessboardCornersMatSizeMatInt() {
+        Size patternSize = new Size(9, 6);
+        Calib3d.findChessboardCorners(grayChess, patternSize, dst, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
+                + Calib3d.CALIB_CB_FAST_CHECK);
+        assertTrue(!dst.empty());
+    }
+
+    public void testFindCirclesGridDefaultMatSizeMat() {
+        int size = 300;
+        Mat img = new Mat(size, size, CvType.CV_8U);
+        img.setTo(new Scalar(255));
+        Mat centers = new Mat();
+
+        assertFalse(Calib3d.findCirclesGridDefault(img, new Size(5, 5), centers));
+
+        for (int i = 0; i < 5; i++)
+            for (int j = 0; j < 5; j++) {
+                Point pt = new Point(size * (2 * i + 1) / 10, size * (2 * j + 1) / 10);
+                Core.circle(img, pt, 10, new Scalar(0), -1);
+            }
+
+        assertTrue(Calib3d.findCirclesGridDefault(img, new Size(5, 5), centers));
+
+        assertEquals(25, centers.rows());
+        assertEquals(1, centers.cols());
+        assertEquals(CvType.CV_32FC2, centers.type());
+    }
+
+    public void testFindCirclesGridDefaultMatSizeMatInt() {
+        int size = 300;
+        Mat img = new Mat(size, size, CvType.CV_8U);
+        img.setTo(new Scalar(255));
+        Mat centers = new Mat();
+
+        assertFalse(Calib3d.findCirclesGridDefault(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING
+                | Calib3d.CALIB_CB_ASYMMETRIC_GRID));
+
+        int step = size * 2 / 15;
+        int offsetx = size / 6;
+        int offsety = (size - 4 * step) / 2;
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 5; j++) {
+                Point pt = new Point(offsetx + (2 * i + j % 2) * step, offsety + step * j);
+                Core.circle(img, pt, 10, new Scalar(0), -1);
+            }
+
+        assertTrue(Calib3d.findCirclesGridDefault(img, new Size(3, 5), centers, Calib3d.CALIB_CB_CLUSTERING
+                | Calib3d.CALIB_CB_ASYMMETRIC_GRID));
+
+        assertEquals(15, centers.rows());
+        assertEquals(1, centers.cols());
+        assertEquals(CvType.CV_32FC2, centers.type());
+    }
+
+    public void testFindFundamentalMatListOfPointListOfPoint() {
+        List<Point> pts1 = new ArrayList<Point>();
+        List<Point> pts2 = new ArrayList<Point>();
+
+        int minFundamentalMatPoints = 8;
+        for (int i = 0; i < minFundamentalMatPoints; i++) {
+            double x = Math.random() * 100 - 50;
+            double y = Math.random() * 100 - 50;
+            pts1.add(new Point(x, y));
+            pts2.add(new Point(x, y));
+        }
+
+        Mat fm = Calib3d.findFundamentalMat(pts1, pts2);
+
+        truth = new Mat(3, 3, CvType.CV_64F);
+        truth.put(0, 0, 0, -0.5, -0.5, 0.5, 0, 0, 0.5, 0, 0);
+        assertMatEqual(truth, fm, EPS);
+    }
+
+    public void testFindFundamentalMatListOfPointListOfPointInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindFundamentalMatListOfPointListOfPointIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindFundamentalMatListOfPointListOfPointIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindFundamentalMatListOfPointListOfPointIntDoubleDoubleMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindHomographyListOfPointListOfPoint() {
+        List<Point> originalPoints = new ArrayList<Point>();
+        List<Point> transformedPoints = new ArrayList<Point>();
+
+        for (int i = 0; i < 20; i++) {
+            double x = Math.random() * 100 - 50;
+            double y = Math.random() * 100 - 50;
+            originalPoints.add(new Point(x, y));
+            transformedPoints.add(new Point(y, x));
+        }
+
+        Mat hmg = Calib3d.findHomography(originalPoints, transformedPoints);
+
+        truth = new Mat(3, 3, CvType.CV_64F);
+        truth.put(0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1);
+
+        assertMatEqual(truth, hmg, EPS);
+    }
+
+    public void testFindHomographyListOfPointListOfPointInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindHomographyListOfPointListOfPointIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindHomographyListOfPointListOfPointIntDoubleMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetOptimalNewCameraMatrixMatMatSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetOptimalNewCameraMatrixMatMatSizeDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetOptimalNewCameraMatrixMatMatSizeDoubleSizeRect() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetOptimalNewCameraMatrixMatMatSizeDoubleSizeRectBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetValidDisparityROI() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitCameraMatrix2DListOfMatListOfMatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitCameraMatrix2DListOfMatListOfMatSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatMulDeriv() {
+        fail("Not yet implemented");
+    }
+
+    public void testProjectPointsMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testProjectPointsMatMatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testProjectPointsMatMatMatMatMatMatMatDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testRectify3Collinear() {
+        fail("Not yet implemented");
+    }
+
+    public void testReprojectImageTo3DMatMatMat() {
+        Mat transformMatrix = new Mat(4, 4, CvType.CV_64F);
+        transformMatrix.put(0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+
+        Mat disparity = new Mat(matSize, matSize, CvType.CV_32F);
+
+        float[] disp = new float[matSize * matSize];
+        for (int i = 0; i < matSize; i++)
+            for (int j = 0; j < matSize; j++)
+                disp[i * matSize + j] = i - j;
+        disparity.put(0, 0, disp);
+
+        Mat _3dPoints = new Mat();
+
+        Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix);
+
+        assertEquals(CvType.CV_32FC3, _3dPoints.type());
+        assertEquals(matSize, _3dPoints.rows());
+        assertEquals(matSize, _3dPoints.cols());
+
+        truth = new Mat(matSize, matSize, CvType.CV_32FC3);
+
+        float[] _truth = new float[matSize * matSize * 3];
+        for (int i = 0; i < matSize; i++)
+            for (int j = 0; j < matSize; j++) {
+                _truth[(i * matSize + j) * 3 + 0] = i;
+                _truth[(i * matSize + j) * 3 + 1] = j;
+                _truth[(i * matSize + j) * 3 + 2] = i - j;
+            }
+        truth.put(0, 0, _truth);
+
+        assertMatEqual(truth, _3dPoints, EPS);
+    }
+
+    public void testReprojectImageTo3DMatMatMatBoolean() {
+        Mat transformMatrix = new Mat(4, 4, CvType.CV_64F);
+        transformMatrix.put(0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+
+        Mat disparity = new Mat(matSize, matSize, CvType.CV_32F);
+
+        float[] disp = new float[matSize * matSize];
+        for (int i = 0; i < matSize; i++)
+            for (int j = 0; j < matSize; j++)
+                disp[i * matSize + j] = i - j;
+        disp[0] = -Float.MAX_VALUE;
+        disparity.put(0, 0, disp);
+
+        Mat _3dPoints = new Mat();
+
+        Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix, true);
+
+        assertEquals(CvType.CV_32FC3, _3dPoints.type());
+        assertEquals(matSize, _3dPoints.rows());
+        assertEquals(matSize, _3dPoints.cols());
+
+        truth = new Mat(matSize, matSize, CvType.CV_32FC3);
+
+        float[] _truth = new float[matSize * matSize * 3];
+        for (int i = 0; i < matSize; i++)
+            for (int j = 0; j < matSize; j++) {
+                _truth[(i * matSize + j) * 3 + 0] = i;
+                _truth[(i * matSize + j) * 3 + 1] = j;
+                _truth[(i * matSize + j) * 3 + 2] = i - j;
+            }
+        _truth[2] = 10000;
+        truth.put(0, 0, _truth);
+
+        assertMatEqual(truth, _3dPoints, EPS);
+    }
+
+    public void testReprojectImageTo3DMatMatMatBooleanInt() {
+        Mat transformMatrix = new Mat(4, 4, CvType.CV_64F);
+        transformMatrix.put(0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+
+        Mat disparity = new Mat(matSize, matSize, CvType.CV_32F);
+
+        float[] disp = new float[matSize * matSize];
+        for (int i = 0; i < matSize; i++)
+            for (int j = 0; j < matSize; j++)
+                disp[i * matSize + j] = i - j;
+        disparity.put(0, 0, disp);
+
+        Mat _3dPoints = new Mat();
+
+        Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix, false, CvType.CV_16S);
+
+        assertEquals(CvType.CV_16SC3, _3dPoints.type());
+        assertEquals(matSize, _3dPoints.rows());
+        assertEquals(matSize, _3dPoints.cols());
+
+        truth = new Mat(matSize, matSize, CvType.CV_16SC3);
+
+        short[] _truth = new short[matSize * matSize * 3];
+        for (short i = 0; i < matSize; i++)
+            for (short j = 0; j < matSize; j++) {
+                _truth[(i * matSize + j) * 3 + 0] = i;
+                _truth[(i * matSize + j) * 3 + 1] = j;
+                _truth[(i * matSize + j) * 3 + 2] = (short) (i - j);
+            }
+        truth.put(0, 0, _truth);
+
+        assertMatEqual(truth, _3dPoints, EPS);
+    }
+
+    public void testRodriguesMatMat() {
+        Mat r = new Mat(3, 1, CvType.CV_32F);
+        Mat R = new Mat(3, 3, CvType.CV_32F);
+
+        r.put(0, 0, Math.PI, 0, 0);
+
+        Calib3d.Rodrigues(r, R);
+
+        truth = new Mat(3, 3, CvType.CV_32F);
+        truth.put(0, 0, 1, 0, 0, 0, -1, 0, 0, 0, -1);
+        assertMatEqual(truth, R, EPS);
+
+        Mat r2 = new Mat();
+        Calib3d.Rodrigues(R, r2);
+
+        assertMatEqual(r, r2, EPS);
+    }
+
+    public void testRodriguesMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRQDecomp3x3MatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRQDecomp3x3MatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRQDecomp3x3MatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRQDecomp3x3MatMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPListOfPoint3ListOfPointMatMatMatMat() {
+        Mat intrinsics = Mat.eye(3, 3, CvType.CV_32F);
+        intrinsics.put(0, 0, 400);
+        intrinsics.put(1, 1, 400);
+        intrinsics.put(0, 2, 640 / 2);
+        intrinsics.put(1, 2, 480 / 2);
+
+        List<Point3> points3d = new ArrayList<Point3>();
+        List<Point> points2d = new ArrayList<Point>();
+        int minPnpPointsNum = 4;
+
+        for (int i = 0; i < minPnpPointsNum; i++) {
+            double x = Math.random() * 100 - 50;
+            double y = Math.random() * 100 - 50;
+            points2d.add(new Point(x, y));
+            points3d.add(new Point3(0, y, x));
+        }
+
+        Mat rvec = new Mat();
+        Mat tvec = new Mat();
+        Calib3d.solvePnP(points3d, points2d, intrinsics, new Mat(), rvec, tvec);
+
+        Mat truth_rvec = new Mat(3, 1, CvType.CV_64F);
+        truth_rvec.put(0, 0, 0, Math.PI / 2, 0);
+
+        Mat truth_tvec = new Mat(3, 1, CvType.CV_64F);
+        truth_tvec.put(0, 0, -320, -240, 400);
+
+        assertMatEqual(truth_rvec, rvec, EPS);
+        assertMatEqual(truth_tvec, tvec, EPS);
+    }
+
+    public void testSolvePnPListOfPoint3ListOfPointMatMatMatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMatBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMatBooleanIntFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMatBooleanIntFloatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSolvePnPRansacListOfPoint3ListOfPointMatMatMatMatBooleanIntFloatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoCalibrateListOfMatListOfMatListOfMatMatMatMatMatSizeMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoCalibrateListOfMatListOfMatListOfMatMatMatMatMatSizeMatMatMatMatTermCriteria() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoCalibrateListOfMatListOfMatListOfMatMatMatMatMatSizeMatMatMatMatTermCriteriaInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoRectifyUncalibratedMatMatMatSizeMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoRectifyUncalibratedMatMatMatSizeMatMatDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testValidateDisparityMatMatIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testValidateDisparityMatMatIntIntInt() {
+        fail("Not yet implemented");
+    }
+}
diff --git a/modules/java/android_test/src/org/opencv/test/calib3d/StereoBMTest.java b/modules/java/android_test/src/org/opencv/test/calib3d/StereoBMTest.java
new file mode 100644
index 0000000000..eac6673985
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/calib3d/StereoBMTest.java
@@ -0,0 +1,31 @@
+package org.opencv.test.calib3d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class StereoBMTest extends OpenCVTestCase {
+
+    public void testComputeMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatMatMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoBM() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoBMInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoBMIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoBMIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/calib3d/StereoSGBMTest.java b/modules/java/android_test/src/org/opencv/test/calib3d/StereoSGBMTest.java
new file mode 100644
index 0000000000..897d2908ed
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/calib3d/StereoSGBMTest.java
@@ -0,0 +1,139 @@
+package org.opencv.test.calib3d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class StereoSGBMTest extends OpenCVTestCase {
+
+    public void testCompute() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_disp12MaxDiff() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_fullDP() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_minDisparity() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_numberOfDisparities() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_P1() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_P2() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_preFilterCap() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_SADWindowSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_speckleRange() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_speckleWindowSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_uniquenessRatio() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_disp12MaxDiff() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_fullDP() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_minDisparity() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_numberOfDisparities() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_P1() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_P2() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_preFilterCap() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_SADWindowSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_speckleRange() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_speckleWindowSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_uniquenessRatio() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBM() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntIntIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testStereoSGBMIntIntIntIntIntIntIntIntIntIntBoolean() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/CoreTest.java b/modules/java/android_test/src/org/opencv/test/core/CoreTest.java
new file mode 100644
index 0000000000..71fe5fb9c9
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/CoreTest.java
@@ -0,0 +1,2468 @@
+package org.opencv.test.core;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.Core.MinMaxLocResult;
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.RotatedRect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.core.TermCriteria;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class CoreTest extends OpenCVTestCase {
+
+    public void testAbsdiff() {
+        Core.absdiff(gray128, gray255, dst);
+
+        assertMatEqual(gray127, dst);
+    }
+
+    public void testAddMatMatMat() {
+        Core.add(gray128, gray128, dst);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testAddMatMatMatMat() {
+        Mat mask = makeMask(gray1.clone());
+        dst = gray127.clone();
+
+        Core.add(gray127, gray1, dst, mask);
+
+        assertMatEqual(makeMask(gray128, 127), dst);
+    }
+
+    public void testAddMatMatMatMatInt() {
+        Core.add(gray0, gray1, dst, gray1, CvType.CV_32F);
+
+        assertEquals(CvType.CV_32F, dst.depth());
+        assertMatEqual(gray1_32f, dst, EPS);
+    }
+
+    public void testAddWeightedMatDoubleMatDoubleDoubleMat() {
+        Core.addWeighted(gray1, 120.0, gray127, 1.0, 10.0, dst);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testAddWeightedMatDoubleMatDoubleDoubleMatInt() {
+        Core.addWeighted(gray1, 126.0, gray127, 1.0, 2.0, dst, CvType.CV_32F);
+
+        assertEquals(CvType.CV_32F, dst.depth());
+        assertMatEqual(gray255_32f, dst, EPS);
+    }
+
+    public void testBitwise_andMatMatMat() {
+        Core.bitwise_and(gray127, gray3, dst);
+
+        assertMatEqual(gray3, dst);
+    }
+
+    public void testBitwise_andMatMatMatMat() {
+        Core.bitwise_and(gray3, gray1, dst, gray255);
+
+        assertMatEqual(gray1, dst);
+    }
+
+    public void testBitwise_notMatMat() {
+        Core.bitwise_not(gray255, dst);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testBitwise_notMatMatMat() {
+        Core.bitwise_not(gray0, dst, gray1);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testBitwise_orMatMatMat() {
+        Core.bitwise_or(gray1, gray2, dst);
+
+        assertMatEqual(gray3, dst);
+    }
+
+    public void testBitwise_orMatMatMatMat() {
+        Core.bitwise_or(gray127, gray3, dst, gray255);
+
+        assertMatEqual(gray127, dst);
+    }
+
+    public void testBitwise_xorMatMatMat() {
+        Core.bitwise_xor(gray3, gray2, dst);
+
+        assertMatEqual(gray1, dst);
+    }
+
+    public void testBitwise_xorMatMatMatMat() {
+        Core.bitwise_or(gray127, gray128, dst, gray255);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testCalcCovarMatrixMatMatMatInt() {
+        Mat covar = new Mat(matSize, matSize, CvType.CV_64FC1);
+        Mat mean = new Mat(1, matSize, CvType.CV_64FC1);
+
+        Core.calcCovarMatrix(gray0_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL);
+
+        assertMatEqual(gray0_64f, covar, EPS);
+        assertMatEqual(gray0_64f_1d, mean, EPS);
+    }
+
+    public void testCalcCovarMatrixMatMatMatIntInt() {
+        Mat covar = new Mat(matSize, matSize, CvType.CV_32F);
+        Mat mean = new Mat(1, matSize, CvType.CV_32F);
+
+        Core.calcCovarMatrix(gray0_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL, CvType.CV_32F);
+
+        assertMatEqual(gray0_32f, covar, EPS);
+        assertMatEqual(gray0_32f_1d, mean, EPS);
+    }
+
+    public void testCartToPolarMatMatMatMat() {
+        Mat x = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 3.0, 6.0, 5, 0);
+            }
+        };
+        Mat y = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0, 8.0, 12.0);
+            }
+        };
+        Mat dst_angle = new Mat();
+
+        Core.cartToPolar(x, y, dst, dst_angle);
+
+        Mat magnitude = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 5.0, 10.0, 13.0);
+            }
+        };
+        Mat angle = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0.92729962, 0.92729962, 1.1759995);
+            }
+        };
+        assertMatEqual(magnitude, dst, EPS);
+        assertMatEqual(angle, dst_angle, EPS);
+    }
+
+    public void testCartToPolarMatMatMatMatBoolean() {
+        Mat x = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 3.0, 6.0, 5, 0);
+            }
+        };
+        Mat y = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0, 8.0, 12.0);
+            }
+        };
+        Mat dst_angle = new Mat();
+
+        Core.cartToPolar(x, y, dst, dst_angle, true);
+
+        Mat magnitude = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 5.0, 10.0, 13.0);
+            }
+        };
+        Mat angle = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 53.130356, 53.130356, 67.379814);
+            }
+        };
+        assertMatEqual(magnitude, dst, EPS);
+        assertMatEqual(angle, dst_angle, EPS);
+    }
+
+    public void testCheckRangeMat() {
+        Mat outOfRange = new Mat(2, 2, CvType.CV_64F);
+        outOfRange.put(0, 0, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0);
+
+        assertTrue(Core.checkRange(grayRnd_32f));
+        assertTrue(Core.checkRange(new Mat()));
+        assertFalse(Core.checkRange(outOfRange));
+    }
+
+    public void testCheckRangeMatBoolean() {
+        Mat outOfRange = new Mat(2, 2, CvType.CV_64F);
+        outOfRange.put(0, 0, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0);
+
+        assertFalse(Core.checkRange(outOfRange, true));
+
+        try {
+            Core.checkRange(outOfRange, false);
+            fail("Core.checkRange should throw the CvException");
+        } catch (CvException e) {
+            // expected
+        }
+    }
+
+    public void testCheckRangeMatBooleanPoint() {
+        Mat outOfRange = new Mat(2, 3, CvType.CV_64F);
+        outOfRange.put(0, 0, 1, 2, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0);
+        Point pt = new Point();
+
+        assertFalse(Core.checkRange(outOfRange, true, null));
+        assertFalse(Core.checkRange(outOfRange, true, pt));
+
+        assertPointEquals(new Point(2, 0), pt, EPS);
+    }
+
+    public void testCheckRangeMatBooleanPointDouble() {
+        assertFalse(Core.checkRange(gray255, true, null, 256));
+        assertTrue(Core.checkRange(gray0, true, null, 0));
+    }
+
+    public void testCheckRangeMatBooleanPointDoubleDouble() {
+        Mat inRange = new Mat(2, 3, CvType.CV_64F) {
+            {
+                put(0, 0, 14, 48, 76, 33, 5, 99);
+            }
+        };
+
+        assertTrue(Core.checkRange(inRange, true, null, 5, 100));
+
+        Mat outOfRange = new Mat(2, 3, CvType.CV_64F) {
+            {
+                put(0, 0, -4, 0, 6, 33, 4, 109);
+            }
+        };
+
+        assertFalse(Core.checkRange(outOfRange, true, null, 5, 100));
+    }
+
+    public void testCircleMatPointIntScalar() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
+        Scalar color = new Scalar(128);
+
+        Core.circle(gray0, center, radius, color);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testCircleMatPointIntScalarInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
+        Scalar color = new Scalar(128);
+
+        Core.circle(gray0, center, radius, color, Core.FILLED);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testCircleMatPointIntScalarIntInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
+        Scalar color = new Scalar(128);
+
+        Core.circle(gray0, center, radius, color, 2, Core.LINE_4);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testCircleMatPointIntScalarIntIntInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Point center2 = new Point(gray0.cols(), gray0.rows());
+        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
+        Scalar color128 = new Scalar(128);
+        Scalar color0 = new Scalar(0);
+
+        Core.circle(gray0, center2, radius * 2, color128, 2, Core.LINE_4, 1/*
+                                                                            * Number
+                                                                            * of
+                                                                            * fractional
+                                                                            * bits
+                                                                            */);
+        assertFalse(0 == Core.countNonZero(gray0));
+
+        Core.circle(gray0, center, radius, color0, 2, Core.LINE_4, 0);
+
+        assertTrue(0 == Core.countNonZero(gray0));
+    }
+
+    public void testClipLine() {
+        Rect r = new Rect(10, 10, 10, 10);
+        Point pt1 = new Point(5.0, 15.0);
+        Point pt2 = new Point(25.0, 15.0);
+
+        assertTrue(Core.clipLine(r, pt1, pt2));
+
+        Point pt1Clipped = new Point(10.0, 15.0);
+        Point pt2Clipped = new Point(19.0, 15.0);
+        assertEquals(pt1Clipped, pt1);
+        assertEquals(pt2Clipped, pt2);
+
+        pt1 = new Point(5.0, 5.0);
+        pt2 = new Point(25.0, 5.0);
+        pt1Clipped = new Point(5.0, 5.0);
+        pt2Clipped = new Point(25.0, 5.0);
+
+        assertFalse(Core.clipLine(r, pt1, pt2));
+
+        assertEquals(pt1Clipped, pt1);
+        assertEquals(pt2Clipped, pt2);
+    }
+
+    public void testCompare() {
+        Core.compare(gray0, gray0, dst, Core.CMP_EQ);
+
+        assertMatEqual(dst, gray255);
+
+        Core.compare(gray0, gray1, dst, Core.CMP_EQ);
+
+        assertMatEqual(dst, gray0);
+
+        grayRnd.put(0, 0, 0, 0);
+
+        Core.compare(gray0, grayRnd, dst, Core.CMP_GE);
+
+        int expected = (int) (grayRnd.total() - Core.countNonZero(grayRnd));
+        assertEquals(expected, Core.countNonZero(dst));
+    }
+
+    public void testCompleteSymmMat() {
+        Core.completeSymm(grayRnd_32f);
+
+        assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);
+    }
+
+    public void testCompleteSymmMatBoolean() {
+        Mat grayRnd_32f2 = grayRnd_32f.clone();
+
+        Core.completeSymm(grayRnd_32f, true);
+
+        assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);
+        Core.completeSymm(grayRnd_32f2, false);
+        assertMatNotEqual(grayRnd_32f2, grayRnd_32f, EPS);
+    }
+
+    public void testConvertScaleAbsMatMat() {
+        Core.convertScaleAbs(gray0, dst);
+
+        assertMatEqual(gray0, dst, EPS);
+
+        Core.convertScaleAbs(gray_16u_256, dst);
+
+        assertMatEqual(gray255, dst, EPS);
+    }
+
+    public void testConvertScaleAbsMatMatDouble() {
+        Core.convertScaleAbs(gray0, dst, 2);
+
+        assertMatEqual(gray0, dst);
+
+        Core.convertScaleAbs(gray_16u_256, dst, 2);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testConvertScaleAbsMatMatDoubleDouble() {
+        Core.convertScaleAbs(gray_16u_256, dst, 2, -513);
+
+        assertMatEqual(gray1, dst);
+    }
+
+    public void testCountNonZero() {
+        assertEquals(0, Core.countNonZero(gray0));
+
+        gray0.put(0, 0, 255);
+        gray0.put(gray0.rows() - 1, gray0.cols() - 1, 255);
+
+        assertEquals(2, Core.countNonZero(gray0));
+    }
+
+    public void testCubeRoot() {
+        float res = Core.cubeRoot(-27.0f);
+
+        assertEquals(-3.0f, res);
+    }
+
+    public void testDctMatMat() {
+        Mat in = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 135.22211, 50.811096, 102.27016, 207.6682);
+            }
+        };
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+
+        Core.dct(gray0_32f_1d, dst1);
+        Core.dct(in, dst2);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 247.98576, -61.252407, 94.904533, 14.013477);
+            }
+        };
+        assertMatEqual(gray0_32f_1d, dst1, EPS);
+        assertMatEqual(truth, dst2, EPS);
+    }
+
+    public void testDctMatMatInt() {
+        Mat in = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 247.98576, -61.252407, 94.904533, 14.013477);
+            }
+        };
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+
+        Core.dct(gray0_32f_1d, dst1, Core.DCT_INVERSE);
+        Core.dct(in, dst2, Core.DCT_INVERSE);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 135.22211, 50.811096, 102.27016, 207.6682);
+            }
+        };
+        assertMatEqual(gray0_32f_1d, dst1, EPS);
+        assertMatEqual(truth, dst2, EPS);
+    }
+
+    public void testDeterminant() {
+        Mat mat = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0);
+                put(0, 1, 2.0);
+                put(1, 0, 4.0);
+                put(1, 1, 4.0);
+            }
+        };
+
+        double det = Core.determinant(mat);
+
+        assertEquals(8.0, det);
+    }
+
+    public void testDftMatMat() {
+        Core.dft(gray0_32f_1d, dst);
+
+        assertMatEqual(gray0_32f_1d, dst, EPS);
+    }
+
+    public void testDftMatMatInt() {
+        Mat src = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 3, 4);
+            }
+        };
+
+        Core.dft(src, dst, Core.DFT_REAL_OUTPUT);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 10, -2, 2, -2);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+
+        Core.dft(src, dst, Core.DFT_INVERSE);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 9, -9, 1, 3);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testDftMatMatIntInt() {
+        Mat src1 = new Mat(2, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 3, 4);
+                put(1, 0, 1, 1, 1, 1);
+            }
+        };
+        Mat src2 = new Mat(2, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 3, 4);
+                put(1, 0, 0, 0, 0, 0);
+            }
+        };
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+
+        Core.dft(src1, dst1, Core.DFT_REAL_OUTPUT, 1);
+        Core.dft(src2, dst2, Core.DFT_REAL_OUTPUT, 0);
+
+        assertMatEqual(dst2, dst1, EPS);
+    }
+
+    public void testDivideDoubleMatMat() {
+        Core.divide(4.0, gray2, dst);
+
+        assertMatEqual(gray2, dst);
+
+        Core.divide(4.0, gray0, dst);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testDivideDoubleMatMatInt() {
+        Core.divide(9.0, gray3, dst, CvType.CV_32F);
+
+        assertMatEqual(gray3_32f, dst, EPS);
+    }
+
+    public void testDivideMatMatMat() {
+        Core.divide(gray9, gray3, dst);
+
+        assertMatEqual(gray3, dst);
+    }
+
+    public void testDivideMatMatMatDouble() {
+        Core.divide(gray1, gray2, dst, 6.0);
+
+        assertMatEqual(gray3, dst);
+    }
+
+    public void testDivideMatMatMatDoubleInt() {
+        Core.divide(gray1, gray2, dst, 6.0, CvType.CV_32F);
+
+        assertMatEqual(gray3_32f, dst, EPS);
+    }
+
+    public void testEigen() {
+        Mat src = new Mat(3, 3, CvType.CV_32FC1, new Scalar(2.0));
+        Mat eigenVals = new Mat();
+        Mat eigenVecs = new Mat();
+
+        Core.eigen(src, true, eigenVals, eigenVecs);
+
+        Mat expectedEigenVals = new Mat(3, 1, CvType.CV_32FC1) {
+            {
+                put(0, 0, 6, 0, 0);
+            }
+        };
+        Mat expectedEigenVecs = new Mat(3, 3, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0.57735026, 0.57735026, 0.57735032);
+                put(1, 0, 0.70710677, -0.70710677, 0);
+                put(2, 0, -0.40824831, -0.40824831, 0.81649661);
+            }
+        };
+        assertMatEqual(eigenVals, expectedEigenVals, EPS);
+        assertMatEqual(eigenVecs, expectedEigenVecs, EPS);
+    }
+
+    public void testEllipse2Poly() {
+        Point center = new Point(4, 4);
+        Size axes = new Size(2, 2);
+        int angle = 30;
+        int arcStart = 30;
+        int arcEnd = 60;
+        int delta = 2;
+        List<Point> pts = new ArrayList<Point>();
+
+        Core.ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta, pts);
+
+        List<Point> truth = Arrays.asList(
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(5, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6),
+                new Point(4, 6));
+        assertListPointEquals(truth, pts, EPS);
+    }
+
+    public void testEllipseMatPointSizeDoubleDoubleDoubleScalar() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Size axes = new Size(2, 2);
+        double angle = 30, startAngle = 60, endAngle = 90;
+
+        Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testEllipseMatPointSizeDoubleDoubleDoubleScalarInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Size axes = new Size(2, 2);
+        double angle = 30, startAngle = 60, endAngle = 90;
+
+        Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testEllipseMatPointSizeDoubleDoubleDoubleScalarIntInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Size axes = new Size(2, 2);
+        double angle = 30, startAngle = 0, endAngle = 30;
+
+        Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED, Core.LINE_4);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testEllipseMatPointSizeDoubleDoubleDoubleScalarIntIntInt() {
+        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Size axes = new Size(2, 2);
+        Point center2 = new Point(gray0.cols(), gray0.rows());
+        Size axes2 = new Size(4, 4);
+        double angle = 30, startAngle = 0, endAngle = 30;
+
+        Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED, Core.LINE_4, 0);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+
+        Core.ellipse(gray0, center2, axes2, angle, startAngle, endAngle, colorBlack, Core.FILLED, Core.LINE_4, 1);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testEllipseMatRotatedRectScalar() {
+        int matSize = 10;
+        Mat gray0 = Mat.zeros(matSize, matSize, CvType.CV_8U);
+        Point center = new Point(matSize / 2, matSize / 2);
+        Size size = new Size(matSize / 4, matSize / 2);
+        RotatedRect box = new RotatedRect(center, size, 45);
+
+        Core.ellipse(gray0, box, new Scalar(1));
+
+        final byte[] truth = new byte[] {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+                0, 0, 0, 0, 1, 1, 0, 1, 0, 0,
+                0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
+                0, 0, 0, 1, 0, 1, 1, 0, 0, 0,
+                0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+        assertMatEqual(new Mat(matSize, matSize, CvType.CV_8U) {
+            {
+                put(0, 0, truth);
+            }
+        }, gray0);
+    }
+
+    public void testEllipseMatRotatedRectScalarInt() {
+        Point center = new Point(matSize / 2, matSize / 2);
+        Size size = new Size(matSize / 4, matSize / 2);
+        RotatedRect box = new RotatedRect(center, size, 45);
+
+        Core.ellipse(gray0, box, new Scalar(1), Core.FILLED);
+        Core.ellipse(gray0, box, new Scalar(0));
+
+        assertTrue(0 < Core.countNonZero(gray0));
+    }
+
+    public void testEllipseMatRotatedRectScalarIntInt() {
+        Point center = new Point(matSize / 2, matSize / 2);
+        Size size = new Size(2, matSize * 2 / 3);
+        RotatedRect box = new RotatedRect(center, size, 20);
+
+        Core.ellipse(gray0, box, new Scalar(9), 1, Core.LINE_AA);
+        Core.ellipse(gray0, box, new Scalar(0), 1, Core.LINE_4);
+
+        assertTrue(0 < Core.countNonZero(gray0));
+    }
+
+    public void testExp() {
+        Core.exp(gray0_32f, dst);
+
+        assertMatEqual(gray1_32f, dst, EPS);
+    }
+
+    public void testExtractChannel() {
+        Core.extractChannel(rgba128, dst, 0);
+
+        assertMatEqual(gray128, dst);
+    }
+
+    public void testFastAtan2() {
+        double eps = 0.3;
+
+        float res = Core.fastAtan2(50, 50);
+
+        assertEquals(45, res, eps);
+
+        float res2 = Core.fastAtan2(80, 20);
+
+        assertEquals(Math.atan2(80, 20) * 180 / Math.PI, res2, eps);
+    }
+
+    public void testFillConvexPolyMatListOfPointScalar() {
+        List<Point> polyline = Arrays.asList(new Point(1, 1), new Point(5, 0), new Point(6, 8), new Point(0, 9));
+
+        Core.fillConvexPoly(gray0, polyline, new Scalar(150));
+
+        assertTrue(0 < Core.countNonZero(gray0));
+        assertTrue(gray0.total() > Core.countNonZero(gray0));
+    }
+
+    public void testFillConvexPolyMatListOfPointScalarInt() {
+        List<Point> polyline = Arrays.asList(new Point(1, 1), new Point(5, 0), new Point(6, 8), new Point(0, 9));
+
+        Core.fillConvexPoly(gray0, polyline, new Scalar(150), Core.LINE_8);
+        Core.fillConvexPoly(gray0, polyline, new Scalar(0), Core.LINE_4);
+
+        assertTrue(0 < Core.countNonZero(gray0));
+        assertTrue(gray0.total() > Core.countNonZero(gray0));
+    }
+
+    public void testFillConvexPolyMatListOfPointScalarIntInt() {
+        List<Point> polyline1 = Arrays.asList(new Point(2, 1), new Point(5, 1), new Point(5, 7), new Point(2, 7));
+        List<Point> polyline2 = Arrays.asList(new Point(4, 2), new Point(10, 2), new Point(10, 14), new Point(4, 14));
+
+        // current implementation of fixed-point version of fillConvexPoly
+        // requires image to be at least 2-pixel wider in each direction than
+        // contour
+        Core.fillConvexPoly(gray0, polyline1, colorWhite, Core.LINE_8, 0);
+
+        assertTrue(0 < Core.countNonZero(gray0));
+        assertTrue(gray0.total() > Core.countNonZero(gray0));
+
+        Core.fillConvexPoly(gray0, polyline2, colorBlack, Core.LINE_8, 1);
+        OpenCVTestRunner.Log(gray0);
+
+        assertEquals("see https://code.ros.org/trac/opencv/ticket/1284", 0, Core.countNonZero(gray0));
+    }
+
+    public void testFillPolyMatListOfListOfPointScalar() {
+        int matSize = 10;
+        Mat gray0 = Mat.zeros(matSize, matSize, CvType.CV_8U);
+        List<Point> polyline = Arrays.asList(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(7, 4));
+        List<List<Point>> polylines = new ArrayList<List<Point>>();
+        polylines.add(polyline);
+
+        Core.fillPoly(gray0, polylines, new Scalar(1));
+
+        final byte[] truth = new byte[] {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+                0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
+                0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+                0, 1, 1, 0, 0, 0, 1, 1, 0, 0,
+                0, 1, 1, 0, 0, 0, 1, 1, 0, 0,
+                0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
+                0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+        assertMatEqual(new Mat(gray0.size(), CvType.CV_8U) {
+            {
+                put(0, 0, truth);
+            }
+        }, gray0);
+    }
+
+    public void testFillPolyMatListOfListOfPointScalarInt() {
+        List<Point> polyline = Arrays.asList(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(9, 3));
+        List<List<Point>> polylines = new ArrayList<List<Point>>();
+        polylines.add(polyline);
+
+        Core.fillPoly(gray0, polylines, new Scalar(1), Core.LINE_8);
+        Core.fillPoly(gray0, polylines, new Scalar(0), Core.LINE_4);
+
+        assertTrue(0 < Core.countNonZero(gray0));
+    }
+
+    public void testFillPolyMatListOfListOfPointScalarIntInt() {
+        List<Point> polyline1 = Arrays.asList(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(7, 4));
+        List<Point> polyline2 = Arrays.asList(new Point(2, 8), new Point(2, 16), new Point(8, 2), new Point(14, 16), new Point(14, 8));
+
+        List<List<Point>> polylines1 = new ArrayList<List<Point>>();
+        polylines1.add(polyline1);
+
+        List<List<Point>> polylines2 = new ArrayList<List<Point>>();
+        polylines2.add(polyline2);
+
+        Core.fillPoly(gray0, polylines1, new Scalar(1), Core.LINE_8, 0);
+
+        assertTrue(0 < Core.countNonZero(gray0));
+
+        Core.fillPoly(gray0, polylines2, new Scalar(0), Core.LINE_8, 1);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testFillPolyMatListOfListOfPointScalarIntIntPoint() {
+        List<Point> polyline1 = Arrays.asList(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(7, 4));
+        List<Point> polyline2 = Arrays.asList(new Point(0, 3), new Point(0, 7), new Point(3, 0), new Point(6, 7), new Point(6, 3));
+
+        List<List<Point>> polylines1 = new ArrayList<List<Point>>();
+        polylines1.add(polyline1);
+
+        List<List<Point>> polylines2 = new ArrayList<List<Point>>();
+        polylines2.add(polyline2);
+
+        Core.fillPoly(gray0, polylines1, new Scalar(1), Core.LINE_8, 0, new Point(0, 0));
+
+        assertTrue(0 < Core.countNonZero(gray0));
+
+        Core.fillPoly(gray0, polylines2, new Scalar(0), Core.LINE_8, 0, new Point(1, 1));
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testFlip() {
+        Mat src = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0);
+                put(0, 1, 2.0);
+                put(1, 0, 3.0);
+                put(1, 1, 4.0);
+            }
+        };
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+
+        Core.flip(src, dst1, 0);
+        Core.flip(src, dst2, 1);
+
+        Mat dst_f1 = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 3.0);
+                put(0, 1, 4.0);
+                put(1, 0, 1.0);
+                put(1, 1, 2.0);
+            }
+        };
+        Mat dst_f2 = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 2.0);
+                put(0, 1, 1.0);
+                put(1, 0, 4.0);
+                put(1, 1, 3.0);
+            }
+        };
+        assertMatEqual(dst_f1, dst1, EPS);
+        assertMatEqual(dst_f2, dst2, EPS);
+    }
+
+    public void testGemmMatMatDoubleMatDoubleMat() {
+        Mat m1 = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.0, 0.0);
+                put(1, 0, 1.0, 0.0);
+            }
+        };
+        Mat m2 = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.0, 0.0);
+                put(1, 0, 1.0, 0.0);
+            }
+        };
+        Mat dmatrix = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0.001, 0.001);
+                put(1, 0, 0.001, 0.001);
+            }
+        };
+
+        Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst);
+
+        Mat expected = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.001, 0.001);
+                put(1, 0, 1.001, 0.001);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testGemmMatMatDoubleMatDoubleMatInt() {
+        Mat m1 = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.0, 0.0);
+                put(1, 0, 1.0, 0.0);
+            }
+        };
+        Mat m2 = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.0, 0.0);
+                put(1, 0, 1.0, 0.0);
+            }
+        };
+        Mat dmatrix = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0.001, 0.001);
+                put(1, 0, 0.001, 0.001);
+            }
+        };
+
+        Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst, Core.GEMM_1_T);
+
+        Mat expected = new Mat(2, 2, CvType.CV_32FC1) {
+            {
+                put(0, 0, 2.001, 0.001);
+                put(1, 0, 0.001, 0.001);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testGetCPUTickCount() {
+        long cpuCountStart = 0, actualTickCount;
+
+        cpuCountStart = Core.getCPUTickCount();
+        Core.sumElems(gray255);
+        actualTickCount = Core.getCPUTickCount();
+
+        long expectedTickCount = actualTickCount - cpuCountStart;
+        assertTrue(expectedTickCount > 0);
+    }
+
+    public void testGetNumberOfCPUs() {
+        int cpus = Core.getNumberOfCPUs();
+
+        assertEquals(Runtime.getRuntime().availableProcessors(), cpus);
+    }
+
+    public void testGetOptimalDFTSize() {
+        assertEquals(1, Core.getOptimalDFTSize(0));
+        assertEquals(135, Core.getOptimalDFTSize(133));
+        assertEquals(15, Core.getOptimalDFTSize(13));
+    }
+
+    public void testGetTextSize() {
+        String text = "Android all the way";
+        double fontScale = 2;
+        int thickness = 3;
+        int baseLine[] = new int[1];
+
+        Core.getTextSize(text, Core.FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, thickness, null);
+        Size res = Core.getTextSize(text, Core.FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, thickness, baseLine);
+
+        assertEquals(543.0, res.width);
+        assertEquals(44.0, res.height);
+        assertEquals(20, baseLine[0]);
+    }
+
+    public void testGetTickCount() {
+        long startCount, endCount, count;
+
+        startCount = Core.getTickCount();
+        Core.divide(gray2, gray1, dst);
+        endCount = Core.getTickCount();
+
+        count = endCount - startCount;
+        assertTrue(count > 0);
+    }
+
+    public void testGetTickFrequency() {
+        double freq1 = Core.getTickFrequency();
+        Core.divide(gray2, gray1, dst);
+        double freq2 = Core.getTickFrequency();
+
+        assertTrue(0 < freq1);
+        assertEquals(freq1, freq2);
+    }
+
+    public void testHconcat() {
+        List<Mat> mats = Arrays.asList(Mat.eye(3, 3, CvType.CV_8U), Mat.zeros(3, 2, CvType.CV_8U));
+
+        Core.hconcat(mats, dst);
+
+        assertMatEqual(Mat.eye(3, 5, CvType.CV_8U), dst);
+    }
+
+    public void testIdctMatMat() {
+        Mat in = new Mat(1, 8, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);
+            }
+        };
+
+        Core.idct(in, dst);
+
+        truth = new Mat(1, 8, CvType.CV_32F) {
+            {
+                put(0, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIdctMatMatInt() {
+        Mat in = new Mat(2, 8, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);
+                put(1, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);
+            }
+        };
+
+        Core.idct(in, dst, Core.DCT_ROWS);
+
+        truth = new Mat(2, 8, CvType.CV_32F) {
+            {
+                put(0, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);
+                put(1, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIdftMatMat() {
+        Mat in = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+
+        Core.idft(in, dst);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 9, -9, 1, 3);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIdftMatMatInt() {
+        Mat in = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+
+        Core.idft(in, dst, Core.DFT_SCALE);
+
+        truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2.25, -2.25, 0.25, 0.75);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIdftMatMatIntInt() {
+        Mat in = new Mat(2, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+                put(1, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+        Mat dst = new Mat();
+
+        Core.idft(in, dst, Core.DFT_REAL_OUTPUT, 1);
+
+        truth = new Mat(2, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 18, -18, 2, 6);
+                put(1, 0, 0, 0, 0, 0);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testInRange() {
+        gray0.put(1, 1, 100, 150, 200);
+
+        Core.inRange(gray0, new Scalar(120), new Scalar(160), dst);
+
+        byte vals[] = new byte[3];
+        dst.get(1, 1, vals);
+
+        assertEquals(0, vals[0]);
+        assertEquals(-1, vals[1]);
+        assertEquals(0, vals[2]);
+        assertEquals(1, Core.countNonZero(dst));
+    }
+
+    public void testInsertChannel() {
+        Core.insertChannel(gray0, rgba128, 0);
+        Core.insertChannel(gray0, rgba128, 1);
+        Core.insertChannel(gray0, rgba128, 2);
+        Core.insertChannel(gray0, rgba128, 3);
+
+        assertMatEqual(rgba0, rgba128);
+    }
+
+    public void testInvertMatMat() {
+        Mat src = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0);
+                put(0, 1, 2.0);
+                put(1, 0, 1.5);
+                put(1, 1, 4.0);
+            }
+        };
+
+        Core.invert(src, dst);
+
+        truth = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0);
+                put(0, 1, -2.0);
+                put(1, 0, -1.5);
+                put(1, 1, 1.0);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testInvertMatMatInt() {
+        Mat src = Mat.eye(3, 3, CvType.CV_32FC1);
+        src.put(0, 2, 1);
+
+        double cond = Core.invert(src, dst, Core.DECOMP_SVD);
+
+        truth = Mat.eye(3, 3, CvType.CV_32FC1);
+        truth.put(0, 2, -1);
+        assertMatEqual(truth, dst, EPS);
+        assertEquals(0.3819660544395447, cond);
+    }
+
+    public void testKmeansMatIntMatTermCriteriaIntInt() {
+        Mat data = new Mat(4, 5, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1, 2, 3, 4, 5);
+                put(1, 0, 2, 3, 4, 5, 6);
+                put(2, 0, 5, 4, 3, 2, 1);
+                put(3, 0, 6, 5, 4, 3, 2);
+            }
+        };
+        TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, EPS);
+        Mat labels = new Mat();
+
+        Core.kmeans(data, 2, labels, criteria, 1, Core.KMEANS_PP_CENTERS);
+
+        int[] first_center = new int[1];
+        labels.get(0, 0, first_center);
+        final int c1 = first_center[0];
+        Mat expected_labels = new Mat(4, 1, CvType.CV_32S) {
+            {
+                put(0, 0, c1, c1, 1 - c1, 1 - c1);
+            }
+        };
+        assertMatEqual(expected_labels, labels);
+    }
+
+    public void testKmeansMatIntMatTermCriteriaIntIntMat() {
+        Mat data = new Mat(4, 5, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1, 2, 3, 4, 5);
+                put(1, 0, 2, 3, 4, 5, 6);
+                put(2, 0, 5, 4, 3, 2, 1);
+                put(3, 0, 6, 5, 4, 3, 2);
+            }
+        };
+        TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, EPS);
+        Mat labels = new Mat();
+        Mat centers = new Mat();
+
+        Core.kmeans(data, 2, labels, criteria, 6, Core.KMEANS_RANDOM_CENTERS, centers);
+
+        int[] first_center = new int[1];
+        labels.get(0, 0, first_center);
+        final int c1 = first_center[0];
+        Mat expected_labels = new Mat(4, 1, CvType.CV_32S) {
+            {
+                put(0, 0, c1, c1, 1 - c1, 1 - c1);
+            }
+        };
+        Mat expected_centers = new Mat(2, 5, CvType.CV_32FC1) {
+            {
+                put(c1, 0, 1.5, 2.5, 3.5, 4.5, 5.5);
+                put(1 - c1, 0, 5.5, 4.5, 3.5, 2.5, 1.5);
+            }
+        };
+        assertMatEqual(expected_labels, labels);
+        assertMatEqual(expected_centers, centers, EPS);
+    }
+
+    public void testLineMatPointPointScalar() {
+        int nPoints = Math.min(gray0.cols(), gray0.rows());
+        Point point1 = new Point(0, 0);
+        Point point2 = new Point(nPoints, nPoints);
+        Scalar color = new Scalar(255);
+
+        Core.line(gray0, point1, point2, color);
+
+        assertTrue(nPoints == Core.countNonZero(gray0));
+    }
+
+    public void testLineMatPointPointScalarInt() {
+        int nPoints = Math.min(gray0.cols(), gray0.rows());
+        Point point1 = new Point(0, 0);
+        Point point2 = new Point(nPoints, nPoints);
+
+        Core.line(gray0, point1, point2, colorWhite, 0);
+
+        assertTrue(nPoints == Core.countNonZero(gray0));
+    }
+
+    public void testLineMatPointPointScalarIntInt() {
+        int nPoints = Math.min(gray0.cols(), gray0.rows());
+        Point point1 = new Point(0, 3);
+        Point point2 = new Point(nPoints, nPoints);
+
+        Core.line(gray0, point2, point1, colorWhite, 2, Core.LINE_AA);
+
+        assertFalse(0 == Core.countNonZero(gray0));
+
+        Core.line(gray0, point2, point1, colorBlack, 2, Core.LINE_4);
+
+        assertFalse(0 == Core.countNonZero(gray0));
+    }
+
+    public void testLineMatPointPointScalarIntIntInt() {
+        int nPoints = Math.min(gray0.cols(), gray0.rows());
+        Point point1 = new Point(3, 4);
+        Point point2 = new Point(nPoints, nPoints);
+        Point point1_4 = new Point(3 * 4, 4 * 4);
+        Point point2_4 = new Point(nPoints * 4, nPoints * 4);
+
+        Core.line(gray0, point2, point1, colorWhite, 2, Core.LINE_8, 0);
+
+        assertFalse(0 == Core.countNonZero(gray0));
+
+        Core.line(gray0, point2_4, point1_4, colorBlack, 2, Core.LINE_8, 2);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testLog() {
+        Mat in = new Mat(1, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1.0, 10.0, 100.0, 1000.0);
+            }
+        };
+
+        Core.log(in, dst);
+
+        Mat expected = new Mat(1, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0, 2.3025851, 4.6051702, 6.9077554);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testLUTMatMatMat() {
+        Mat lut = new Mat(1, 256, CvType.CV_8UC1);
+        lut.setTo(new Scalar(0));
+
+        Core.LUT(grayRnd, lut, dst);
+
+        assertMatEqual(gray0, dst);
+
+        lut.setTo(new Scalar(255));
+
+        Core.LUT(grayRnd, lut, dst);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testLUTMatMatMatInt() {
+        Mat lut = new Mat(1, 256, CvType.CV_8UC1);
+        // TODO: ban this overload
+        try
+        {
+            Core.LUT(grayRnd, lut, dst, 1);
+            fail("Last parameter for LUT was not supported");
+        } catch (CvException e) {
+            // expected
+        }
+    }
+
+    public void testMagnitude() {
+        Mat x = new Mat(1, 4, CvType.CV_32F);
+        Mat y = new Mat(1, 4, CvType.CV_32F);
+        x.put(0, 0, 3.0, 5.0, 9.0, 6.0);
+        y.put(0, 0, 4.0, 12.0, 40.0, 8.0);
+
+        Core.magnitude(x, y, dst);
+
+        Mat out = new Mat(1, 4, CvType.CV_32F);
+        out.put(0, 0, 5.0, 13.0, 41.0, 10.0);
+        assertMatEqual(out, dst, EPS);
+
+        Core.magnitude(gray0_32f, gray255_32f, dst);
+
+        assertMatEqual(gray255_32f, dst, EPS);
+    }
+
+    public void testMahalanobis() {
+        Mat covar = new Mat(matSize, matSize, CvType.CV_32F);
+        Mat mean = new Mat(1, matSize, CvType.CV_32F);
+        Core.calcCovarMatrix(grayRnd_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL, CvType.CV_32F);
+        covar = covar.inv();
+        Mat line1 = grayRnd_32f.row(0);
+        Mat line2 = grayRnd_32f.row(1);
+
+        double d = Core.Mahalanobis(line1, line1, covar);
+
+        assertEquals(0.0, d);
+
+        d = Core.Mahalanobis(line1, line2, covar);
+
+        assertTrue(d > 0.0);
+    }
+
+    public void testMax() {
+        Core.max(gray0, gray255, dst);
+
+        assertMatEqual(gray255, dst);
+
+        Mat x = new Mat(1, 1, CvType.CV_32F);
+        Mat y = new Mat(1, 1, CvType.CV_32F);
+        x.put(0, 0, 23.0);
+        y.put(0, 0, 4.0);
+
+        Core.max(x, y, dst);
+
+        Mat truth = new Mat(1, 1, CvType.CV_32F);
+        truth.put(0, 0, 23.0);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMeanMat() {
+        Scalar mean = Core.mean(makeMask(gray128));
+
+        assertScalarEqual(new Scalar(64), mean, EPS);
+    }
+
+    public void testMeanMatMat() {
+        Mat mask1 = makeMask(gray1.clone());
+        Mat mask2 = makeMask(gray0, 1);
+
+        Scalar mean1 = Core.mean(grayRnd, mask1);
+        Scalar mean2 = Core.mean(grayRnd, mask2);
+        Scalar mean = Core.mean(grayRnd, gray1);
+
+        assertScalarEqual(mean, new Scalar(0.5 * (mean1.val[0] + mean2.val[0])), EPS);
+    }
+
+    public void testMeanStdDevMatMatMat() {
+        Mat mean = new Mat();
+        Mat stddev = new Mat();
+
+        Core.meanStdDev(rgbLena, mean, stddev);
+
+        Mat expectedMean = new Mat(3, 1, CvType.CV_64F) {
+            {
+                put(0, 0, 105.3989906311035, 99.56269836425781, 179.7303047180176);
+            }
+        };
+        Mat expectedDev = new Mat(3, 1, CvType.CV_64F) {
+            {
+                put(0, 0, 33.74205485167219, 52.8734582803278, 49.01569488056406);
+            }
+        };
+        assertMatEqual(expectedMean, mean, EPS);
+        assertMatEqual(expectedDev, stddev, EPS);
+    }
+
+    public void testMeanStdDevMatMatMatMat() {
+        Mat submat = grayRnd.submat(0, grayRnd.rows() / 2, 0, grayRnd.cols() / 2);
+        submat.setTo(new Scalar(33));
+        Mat mask = gray0.clone();
+        submat = mask.submat(0, mask.rows() / 2, 0, mask.cols() / 2);
+        submat.setTo(new Scalar(1));
+        Mat mean = new Mat();
+        Mat stddev = new Mat();
+
+        Core.meanStdDev(grayRnd, mean, stddev, mask);
+
+        Mat expectedMean = new Mat(1, 1, CvType.CV_64F, new Scalar(33));
+        Mat expectedDev = new Mat(1, 1, CvType.CV_64F, new Scalar(0));
+        assertMatEqual(expectedMean, mean, EPS);
+        assertMatEqual(expectedDev, stddev, EPS);
+    }
+
+    public void testMerge() {
+        Mat src1 = new Mat(2, 2, CvType.CV_32FC1, new Scalar(1));
+        Mat src2 = new Mat(2, 2, CvType.CV_32FC1, new Scalar(2));
+        Mat src3 = new Mat(2, 2, CvType.CV_32FC1, new Scalar(3));
+        List<Mat> listMat = Arrays.asList(src1, src2, src3);
+
+        Core.merge(listMat, dst);
+
+        truth = new Mat(2, 2, CvType.CV_32FC3, new Scalar(1, 2, 3));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMin() {
+        Core.min(gray0, gray255, dst);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testMinMaxLocMat() {
+        double minVal = 1;
+        double maxVal = 10;
+        Point minLoc = new Point(gray3.cols() / 4, gray3.rows() / 2);
+        Point maxLoc = new Point(gray3.cols() / 2, gray3.rows() / 4);
+        gray3.put((int) minLoc.y, (int) minLoc.x, minVal);
+        gray3.put((int) maxLoc.y, (int) maxLoc.x, maxVal);
+
+        Core.MinMaxLocResult mmres = Core.minMaxLoc(gray3);
+
+        assertEquals(minVal, mmres.minVal);
+        assertEquals(maxVal, mmres.maxVal);
+        assertPointEquals(minLoc, mmres.minLoc, EPS);
+        assertPointEquals(maxLoc, mmres.maxLoc, EPS);
+    }
+
+    public void testMinMaxLocMatMat() {
+        Mat src = new Mat(4, 4, CvType.CV_8U) {
+            {
+                put(0, 0, 2, 4, 27, 3);
+                put(1, 0, 0, 8, 7, 130);
+                put(2, 0, 13, 4, 13, 4);
+                put(3, 0, 6, 4, 2, 13);
+            }
+        };
+        Mat mask = new Mat(4, 4, CvType.CV_8U, new Scalar(0));
+        mask.submat(1, 3, 1, 4).setTo(new Scalar(1));
+
+        MinMaxLocResult res = Core.minMaxLoc(src, mask);
+
+        assertEquals(4.0, res.minVal);
+        assertEquals(130.0, res.maxVal);
+        assertPointEquals(new Point(1, 2), res.minLoc, EPS);
+        assertPointEquals(new Point(3, 1), res.maxLoc, EPS);
+    }
+
+    public void testMixChannels() {
+        rgba0.setTo(new Scalar(10, 20, 30, 40));
+        List<Mat> src = Arrays.asList(rgba0);
+        List<Mat> dst = Arrays.asList(gray3, gray2, gray1, gray0, getMat(CvType.CV_8UC3, 0, 0, 0));
+        List<Integer> fromTo = Arrays.asList(
+                3, 0,
+                3, 1,
+                2, 2,
+                0, 3,
+                2, 4,
+                1, 5,
+                0, 6);
+
+        Core.mixChannels(src, dst, fromTo);
+
+        assertMatEqual(getMat(CvType.CV_8U, 40), dst.get(0));
+        assertMatEqual(getMat(CvType.CV_8U, 40), dst.get(1));
+        assertMatEqual(getMat(CvType.CV_8U, 30), dst.get(2));
+        assertMatEqual(getMat(CvType.CV_8U, 10), dst.get(3));
+        assertMatEqual(getMat(CvType.CV_8UC3, 30, 20, 10), dst.get(4));
+    }
+
+    public void testMulSpectrumsMatMatMatInt() {
+        Mat src1 = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+        Mat src2 = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+
+        Core.mulSpectrums(src1, src2, dst, Core.DFT_ROWS);
+
+        Mat expected = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, -5, 12, 16);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testMulSpectrumsMatMatMatIntBoolean() {
+        Mat src1 = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+        Mat src2 = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+
+        Core.mulSpectrums(src1, src2, dst, Core.DFT_ROWS, true);
+
+        Mat expected = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 13, 0, 16);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testMultiplyMatMatMat() {
+        Core.multiply(gray0, gray255, dst);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testMultiplyMatMatMatDouble() {
+        Core.multiply(gray1, gray1, dst, 2.0);
+
+        assertMatEqual(gray2, dst);
+
+    }
+
+    public void testMultiplyMatMatMatDoubleInt() {
+        Core.multiply(gray1, gray2, dst, 1.5, CvType.CV_32F);
+
+        assertMatEqual(gray3_32f, dst, EPS);
+    }
+
+    public void testMulTransposedMatMatBoolean() {
+        Core.mulTransposed(grayE_32f, dst, true);
+
+        assertMatEqual(grayE_32f, dst, EPS);
+    }
+
+    public void testMulTransposedMatMatBooleanMat() {
+        Core.mulTransposed(grayRnd_32f, dst, false, grayRnd_32f);
+
+        assertMatEqual(gray0_32f, dst, EPS);
+    }
+
+    public void testMulTransposedMatMatBooleanMatDouble() {
+        Core.mulTransposed(grayE_32f, dst, true, gray0_32f, 2);
+
+        truth = gray0_32f;
+        truth.diag().setTo(new Scalar(2));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMulTransposedMatMatBooleanMatDoubleInt() {
+        Mat a = getMat(CvType.CV_32F, 1);
+
+        Core.mulTransposed(a, dst, true, gray0_32f, 3, CvType.CV_64F);
+
+        assertMatEqual(getMat(CvType.CV_64F, 3 * a.rows()), dst, EPS);
+    }
+
+    public void testNormalizeMatMat() {
+        Mat m = gray0.clone();
+        m.diag().setTo(new Scalar(2));
+
+        Core.normalize(m, dst);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testNormalizeMatMatDouble() {
+        Mat m = gray0;
+        m.diag().setTo(new Scalar(1));
+
+        Core.normalize(m, dst, 255);
+
+        truth = Mat.eye(matSize, matSize, CvType.CV_8U);
+        truth.diag().setTo(new Scalar(81));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testNormalizeMatMatDoubleDouble() {
+        Core.normalize(gray0, dst, 0.0, 1.0);
+        // TODO: ban this overload
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testNormalizeMatMatDoubleDoubleInt() {
+        Mat src = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0, 2.0, 3.0, 4.0);
+            }
+        };
+
+        Core.normalize(src, dst, 1.0, 2.0, Core.NORM_INF);
+
+        Mat expected = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 0.25, 0.5, 0.75, 1);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testNormalizeMatMatDoubleDoubleIntInt() {
+        Mat src = new Mat(1, 5, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 1, 2, 3, 4);
+            }
+        };
+
+        Core.normalize(src, dst, 1, 2, Core.NORM_MINMAX, CvType.CV_64F);
+
+        Mat expected = new Mat(1, 5, CvType.CV_64F) {
+            {
+                put(0, 0, 1, 1.25, 1.5, 1.75, 2);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testNormalizeMatMatDoubleDoubleIntIntMat() {
+        Mat src = new Mat(1, 5, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 1, 2, 3, 4);
+            }
+        };
+        Mat mask = new Mat(1, 5, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 0, 0, 0, 1);
+            }
+        };
+        dst = src.clone();
+
+        Core.normalize(src, dst, 1, 2, Core.NORM_MINMAX, CvType.CV_32F, mask);
+
+        Mat expected = new Mat(1, 5, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 1, 2, 3, 2);
+            }
+        };
+        assertMatEqual(expected, dst, EPS);
+    }
+
+    public void testNormMat() {
+        double n = Core.norm(gray1);
+
+        assertEquals(10., n);
+    }
+
+    public void testNormMatInt() {
+        double n = Core.norm(gray127, Core.NORM_INF);
+
+        assertEquals(127., n);
+    }
+
+    public void testNormMatIntMat() {
+        double n = Core.norm(gray3, Core.NORM_L1, gray0);
+
+        assertEquals(0.0, n);
+    }
+
+    public void testNormMatMat() {
+        double n = Core.norm(gray0, gray1);
+
+        assertEquals(10.0, n);
+    }
+
+    public void testNormMatMatInt() {
+        double n = Core.norm(gray127, gray1, Core.NORM_INF);
+
+        assertEquals(126.0, n);
+    }
+
+    public void testNormMatMatIntMat() {
+        double n = Core.norm(gray3, gray0, Core.NORM_L1, makeMask(gray0.clone(), 1));
+
+        assertEquals(150.0, n);
+    }
+
+    public void testPCABackProject() {
+        Mat mean = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 4, 8);
+            }
+        };
+        Mat vectors = new Mat(1, 4, CvType.CV_32F, new Scalar(0)) {
+            {
+                put(0, 0, 0.2, 0.4, 0.4, 0.8);
+            }
+        };
+        Mat data = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -5, 0, -10);
+            }
+        };
+        Mat result = new Mat();
+
+        Core.PCABackProject(data, mean, vectors, result);
+
+        Mat truth = new Mat(3, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 2, 4);
+                put(1, 0, 2, 4, 4, 8);
+                put(2, 0, 0, 0, 0, 0);
+            }
+        };
+        assertMatEqual(truth, result, EPS);
+    }
+
+    public void testPCAComputeMatMatMat() {
+        Mat data = new Mat(3, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 2, 4);
+                put(1, 0, 2, 4, 4, 8);
+                put(2, 0, 3, 6, 6, 12);
+            }
+        };
+        Mat mean = new Mat();
+        Mat vectors = new Mat();
+
+        Core.PCACompute(data, mean, vectors);
+
+        Mat mean_truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 4, 8);
+            }
+        };
+        Mat vectors_truth = new Mat(3, 4, CvType.CV_32F, new Scalar(0)) {
+            {
+                put(0, 0, 0.2, 0.4, 0.4, 0.8);
+            }
+        };
+        assertMatEqual(mean_truth, mean, EPS);
+        assertMatEqual(vectors_truth, vectors, EPS);
+    }
+
+    public void testPCAComputeMatMatMatInt() {
+        Mat data = new Mat(3, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 2, 4);
+                put(1, 0, 2, 4, 4, 8);
+                put(2, 0, 3, 6, 6, 12);
+            }
+        };
+        Mat mean = new Mat();
+        Mat vectors = new Mat();
+
+        Core.PCACompute(data, mean, vectors, 1);
+
+        Mat mean_truth = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 4, 8);
+            }
+        };
+        Mat vectors_truth = new Mat(1, 4, CvType.CV_32F, new Scalar(0)) {
+            {
+                put(0, 0, 0.2, 0.4, 0.4, 0.8);
+            }
+        };
+        assertMatEqual(mean_truth, mean, EPS);
+        assertMatEqual(vectors_truth, vectors, EPS);
+    }
+
+    public void testPCAProject() {
+        Mat mean = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 4, 8);
+            }
+        };
+        Mat vectors = new Mat(1, 4, CvType.CV_32F, new Scalar(0)) {
+            {
+                put(0, 0, 0.2, 0.4, 0.4, 0.8);
+            }
+        };
+        Mat data = new Mat(3, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 2, 2, 4);
+                put(1, 0, 2, 4, 4, 8);
+                put(2, 0, 0, 0, 0, 0);
+            }
+        };
+        Mat result = new Mat();
+
+        Core.PCAProject(data, mean, vectors, result);
+
+        Mat truth = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -5, 0, -10);
+            }
+        };
+        assertMatEqual(truth, result, EPS);
+    }
+
+    public void testPerspectiveTransform() {
+        Mat src = new Mat(matSize, matSize, CvType.CV_32FC2);
+        Core.randu(src, 0, 256);
+        Mat transformMatrix = Mat.eye(3, 3, CvType.CV_32F);
+
+        Core.perspectiveTransform(src, dst, transformMatrix);
+        assertMatEqual(src, dst, EPS);
+    }
+
+    public void testPerspectiveTransform3D() {
+        Mat src = new Mat(matSize, matSize, CvType.CV_32FC3);
+        Core.randu(src, 0, 256);
+        Mat transformMatrix = Mat.eye(4, 4, CvType.CV_32F);
+
+        Core.perspectiveTransform(src, dst, transformMatrix);
+
+        assertMatEqual(src, dst, EPS);
+    }
+
+    public void testPhaseMatMatMat() {
+        Mat x = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 10.0, 10.0, 20.0, 5.0);
+            }
+        };
+        Mat y = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 20.0, 15.0, 20.0, 20.0);
+            }
+        };
+
+        Core.phase(x, y, dst);
+
+        Mat res = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1.1071469, 0.98280007, 0.78539175, 1.3258134);
+            }
+        };
+        assertMatEqual(res, dst, EPS);
+    }
+
+    public void testPhaseMatMatMatBoolean() {
+        Mat x = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 10.0, 10.0, 20.0, 5.0);
+            }
+        };
+        Mat y = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 20.0, 15.0, 20.0, 20.0);
+            }
+        };
+
+        Core.phase(x, y, dst, true);
+
+        Mat res = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 63.434, 56.310, 44.999, 75.963);
+            }
+        };
+        assertMatEqual(res, dst, EPS);
+    }
+
+    public void testPolarToCartMatMatMatMat() {
+        Mat magnitude = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 5.0, 10.0, 13.0);
+            }
+        };
+        Mat angle = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0.92729962, 0.92729962, 1.1759995);
+            }
+        };
+        Mat xCoordinate = new Mat();
+        Mat yCoordinate = new Mat();
+
+        Core.polarToCart(magnitude, angle, xCoordinate, yCoordinate);
+
+        Mat x = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 3.0, 6.0, 5, 0);
+            }
+        };
+        Mat y = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0, 8.0, 12.0);
+            }
+        };
+        assertMatEqual(x, xCoordinate, EPS);
+        assertMatEqual(y, yCoordinate, EPS);
+    }
+
+    public void testPolarToCartMatMatMatMatBoolean() {
+        Mat magnitude = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 5.0, 10.0, 13.0);
+            }
+        };
+        Mat angle = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0.92729962, 0.92729962, 1.1759995);
+            }
+        };
+        Mat xCoordinate = new Mat();
+        Mat yCoordinate = new Mat();
+
+        Core.polarToCart(magnitude, angle, xCoordinate, yCoordinate, true);
+
+        Mat x = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 4.9993458, 9.9986916, 12.997262);
+            }
+        };
+        Mat y = new Mat(1, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0.080918625, 0.16183725, 0.26680708);
+            }
+        };
+        assertMatEqual(x, xCoordinate, EPS);
+        assertMatEqual(y, yCoordinate, EPS);
+    }
+
+    public void testPolylinesMatListOfListOfPointBooleanScalar() {
+        Mat img = gray0;
+        List<List<Point>> polyline = new ArrayList<List<Point>>();
+        polyline.add(Arrays.asList(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
+
+        Core.polylines(img, polyline, true, new Scalar(100));
+
+        assertEquals(22, Core.countNonZero(img));
+
+        Core.polylines(img, polyline, false, new Scalar(0));
+
+        assertEquals(4, Core.countNonZero(img));
+    }
+
+    public void testPolylinesMatListOfListOfPointBooleanScalarInt() {
+        Mat img = gray0;
+        List<List<Point>> polyline = new ArrayList<List<Point>>();
+        polyline.add(Arrays.asList(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
+
+        Core.polylines(img, polyline, true, new Scalar(100), 2);
+
+        assertEquals(62, Core.countNonZero(img));
+    }
+
+    public void testPolylinesMatListOfListOfPointBooleanScalarIntInt() {
+        Mat img = gray0;
+        List<List<Point>> polyline = new ArrayList<List<Point>>();
+        polyline.add(Arrays.asList(new Point(1, 1), new Point(4, 1), new Point(3, 6), new Point(1, 3)));
+
+        Core.polylines(img, polyline, true, new Scalar(100), 2, Core.LINE_4);
+
+        assertEquals(36, Core.countNonZero(img));
+    }
+
+    public void testPolylinesMatListOfListOfPointBooleanScalarIntIntInt() {
+        Mat img = gray0;
+        List<List<Point>> polyline1 = new ArrayList<List<Point>>();
+        polyline1.add(Arrays.asList(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
+        List<List<Point>> polyline2 = new ArrayList<List<Point>>();
+        polyline2.add(Arrays.asList(new Point(2, 2), new Point(14, 2), new Point(14, 12), new Point(2, 12)));
+
+        Core.polylines(img, polyline1, true, new Scalar(100), 2, Core.LINE_8, 0);
+
+        assertTrue(Core.countNonZero(img) > 0);
+
+        Core.polylines(img, polyline2, true, new Scalar(0), 2, Core.LINE_8, 1);
+
+        assertEquals(0, Core.countNonZero(img));
+    }
+
+    public void testPow() {
+        Core.pow(gray2, 7, dst);
+
+        assertMatEqual(gray128, dst);
+    }
+
+    public void testPutTextMatStringPointIntDoubleScalar() {
+        String text = "Hello World";
+        Size labelSize = new Size(175, 22);
+        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
+        Point origin = new Point(10, labelSize.height + 10);
+
+        Core.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite);
+
+        assertTrue(Core.countNonZero(img) > 0);
+        // check that border is not corrupted
+        Core.rectangle(img, new Point(11, 11), new Point(labelSize.width + 10, labelSize.height + 10), colorBlack, Core.FILLED);
+        assertEquals(0, Core.countNonZero(img));
+    }
+
+    public void testPutTextMatStringPointIntDoubleScalarInt() {
+        String text = "Hello World";
+        Size labelSize = new Size(176, 22);
+        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
+        Point origin = new Point(10, labelSize.height + 10);
+
+        Core.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite, 2);
+
+        assertTrue(Core.countNonZero(img) > 0);
+        // check that border is not corrupted
+        Core.rectangle(img, new Point(10, 10), new Point(labelSize.width + 10 + 1, labelSize.height + 10 + 1), colorBlack, Core.FILLED);
+        assertEquals(0, Core.countNonZero(img));
+    }
+
+    public void testPutTextMatStringPointIntDoubleScalarIntInt() {
+        String text = "Hello World";
+        Size labelSize = new Size(175, 22);
+
+        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
+        Point origin = new Point(10, labelSize.height + 10);
+
+        Core.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite, 1, Core.LINE_AA);
+
+        assertTrue(Core.countNonZero(img) > 0);
+        // check that text differs from 8-connected line
+        Core.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorBlack, 1, Core.LINE_8);
+        assertFalse(0 == Core.countNonZero(img));
+    }
+
+    public void testPutTextMatStringPointIntDoubleScalarIntIntBoolean() {
+        String text = "Hello World";
+        Size labelSize = new Size(175, 22);
+
+        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
+        Point origin = new Point(10, 10);
+
+        Core.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite, 1, Core.LINE_8, true);
+
+        assertTrue(Core.countNonZero(img) > 0);
+        // check that border is not corrupted
+        Core.rectangle(img, new Point(10, 10), new Point(labelSize.width + 9, labelSize.height + 9), colorBlack, Core.FILLED);
+        assertEquals(0, Core.countNonZero(img));
+    }
+
+    public void testRandn() {
+        Core.randn(gray0, 100, 23);
+
+        assertEquals(100., Core.mean(gray0).val[0], 23 / 2);
+    }
+
+    public void testRandShuffleMat() {
+        Mat original = new Mat(1, 5, CvType.CV_32F) {
+            {
+                put(0, 0, 7, 5, 2, 8, 1);
+            }
+        };
+        Mat shuffled = original.clone();
+
+        Core.randShuffle(shuffled);
+
+        assertMatNotEqual(original, shuffled, EPS);
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+        Core.sort(original, dst1, Core.SORT_ASCENDING);
+        Core.sort(shuffled, dst2, Core.SORT_ASCENDING);
+        assertMatEqual(dst1, dst2, EPS);
+    }
+
+    public void testRandShuffleMatDouble() {
+        Mat original = new Mat(1, 5, CvType.CV_32F) {
+            {
+                put(0, 0, 7, 5, 2, 8, 1);
+            }
+        };
+        Mat shuffled = original.clone();
+
+        Core.randShuffle(shuffled, 10);
+
+        assertMatNotEqual(original, shuffled, EPS);
+        Mat dst1 = new Mat();
+        Mat dst2 = new Mat();
+        Core.sort(original, dst1, Core.SORT_ASCENDING);
+        Core.sort(shuffled, dst2, Core.SORT_ASCENDING);
+        assertMatEqual(dst1, dst2, EPS);
+    }
+
+    public void testRandu() {
+        Core.randu(gray0, 3, 23);
+
+        assertTrue(Core.checkRange(gray0, true, null, 3, 23));
+    }
+
+    public void testRectangleMatPointPointScalar() {
+        Point bottomRight = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Point topLeft = new Point(0, 0);
+        Scalar color = new Scalar(128);
+
+        Core.rectangle(gray0, bottomRight, topLeft, color);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testRectangleMatPointPointScalarInt() {
+        Point bottomRight = new Point(gray0.cols(), gray0.rows());
+        Point topLeft = new Point(0, 0);
+        Scalar color = new Scalar(128);
+
+        Core.rectangle(gray0, bottomRight, topLeft, color, 2);
+        Core.rectangle(gray0, bottomRight, topLeft, colorBlack);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testRectangleMatPointPointScalarIntInt() {
+        Point bottomRight = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Point topLeft = new Point(0, 0);
+        Scalar color = new Scalar(128);
+
+        Core.rectangle(gray0, bottomRight, topLeft, color, 2, Core.LINE_AA);
+        Core.rectangle(gray0, bottomRight, topLeft, colorBlack, 2, Core.LINE_4);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+    }
+
+    public void testRectangleMatPointPointScalarIntIntInt() {
+        Point bottomRight1 = new Point(gray0.cols(), gray0.rows());
+        Point bottomRight2 = new Point(gray0.cols() / 2, gray0.rows() / 2);
+        Point topLeft = new Point(0, 0);
+        Scalar color = new Scalar(128);
+
+        Core.rectangle(gray0, bottomRight1, topLeft, color, 2, Core.LINE_8, 1);
+
+        assertTrue(0 != Core.countNonZero(gray0));
+
+        Core.rectangle(gray0, bottomRight2, topLeft, colorBlack, 2, Core.LINE_8);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testReduceMatMatIntInt() {
+        Mat src = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0);
+                put(1, 0, 3, 0);
+            }
+        };
+
+        Core.reduce(src, dst, 0, Core.REDUCE_AVG);
+
+        Mat out = new Mat(1, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 0);
+            }
+        };
+        assertMatEqual(out, dst, EPS);
+    }
+
+    public void testReduceMatMatIntIntInt() {
+        Mat src = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0);
+                put(1, 0, 2, 3);
+            }
+        };
+
+        Core.reduce(src, dst, 1, Core.REDUCE_SUM, CvType.CV_64F);
+
+        Mat out = new Mat(2, 1, CvType.CV_64F) {
+            {
+                put(0, 0, 1, 5);
+            }
+        };
+        assertMatEqual(out, dst, EPS);
+    }
+
+    public void testRepeat() {
+        Mat src = new Mat(1, 2, CvType.CV_32F, new Scalar(0));
+
+        Core.repeat(src, matSize, matSize / 2, dst);
+
+        assertMatEqual(gray0_32f, dst, EPS);
+    }
+
+    public void testScaleAdd() {
+        Core.scaleAdd(gray3, 2.0, gray3, dst);
+
+        assertMatEqual(gray9, dst);
+    }
+
+    public void testSetIdentityMat() {
+        Core.setIdentity(gray0_32f);
+
+        assertMatEqual(grayE_32f, gray0_32f, EPS);
+    }
+
+    public void testSetIdentityMatScalar() {
+        Mat m = gray0_32f;
+
+        Core.setIdentity(m, new Scalar(5));
+
+        truth = new Mat(m.size(), m.type(), new Scalar(0));
+        truth.diag().setTo(new Scalar(5));
+        assertMatEqual(truth, m, EPS);
+    }
+
+    public void testSolveCubic() {
+        Mat coeffs = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 6, 11, 6);
+            }
+        };
+
+        assertEquals(3, Core.solveCubic(coeffs, dst));
+
+        Mat roots = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -3, -1, -2);
+            }
+        };
+        assertMatEqual(roots, dst, EPS);
+    }
+
+    public void testSolveMatMatMat() {
+        Mat a = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 1, 1);
+                put(1, 0, 1, -2, 2);
+                put(2, 0, 1, 2, 1);
+            }
+        };
+        Mat b = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 4, 2);
+            }
+        };
+
+        assertTrue(Core.solve(a, b, dst));
+
+        Mat res = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -12, 2, 10);
+            }
+        };
+        assertMatEqual(res, dst, EPS);
+    }
+
+    public void testSolveMatMatMatInt() {
+        Mat a = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 1, 1);
+                put(1, 0, 1, -2, 2);
+                put(2, 0, 1, 2, 1);
+            }
+        };
+        Mat b = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 4, 2);
+            }
+        };
+
+        assertTrue(Core.solve(a, b, dst, Core.DECOMP_QR | Core.DECOMP_NORMAL));
+
+        Mat res = new Mat(3, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -12, 2, 10);
+            }
+        };
+        assertMatEqual(res, dst, EPS);
+    }
+
+    public void testSolvePolyMatMat() {
+        Mat coeffs = new Mat(4, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -6, 11, -6, 1);
+            }
+        };
+        Mat roots = new Mat();
+
+        assertEquals(0.0, Core.solvePoly(coeffs, roots));
+
+        truth = new Mat(3, 1, CvType.CV_32FC2) {
+            {
+                put(0, 0, 1, 0, 2, 0, 3, 0);
+            }
+        };
+        assertMatEqual(truth, roots, EPS);
+    }
+
+    public void testSolvePolyMatMatInt() {
+        Mat coeffs = new Mat(4, 1, CvType.CV_32F) {
+            {
+                put(0, 0, -6, 11, -6, 1);
+            }
+        };
+        Mat roots = new Mat();
+
+        assertEquals(10.198039027185569, Core.solvePoly(coeffs, roots, 1));
+
+        truth = new Mat(3, 1, CvType.CV_32FC2) {
+            {
+                put(0, 0, 1, 0, -1, 2, -2, 12);
+            }
+        };
+        assertMatEqual(truth, roots, EPS);
+    }
+
+    public void testSort() {
+        Mat submat = gray0.submat(0, gray0.rows() / 2, 0, gray0.cols() / 2);
+        submat.setTo(new Scalar(1.0));
+
+        Core.sort(gray0, dst, Core.SORT_EVERY_ROW);
+
+        submat = dst.submat(0, dst.rows() / 2, dst.cols() / 2, dst.cols());
+        assertTrue(submat.total() == Core.countNonZero(submat));
+
+        Core.sort(gray0, dst, Core.SORT_EVERY_COLUMN);
+
+        submat = dst.submat(dst.rows() / 2, dst.rows(), 0, dst.cols() / 2);
+
+        assertTrue(submat.total() == Core.countNonZero(submat));
+    }
+
+    public void testSortIdx() {
+        Mat a = Mat.eye(3, 3, CvType.CV_8UC1);
+        Mat b = new Mat();
+
+        Core.sortIdx(a, b, Core.SORT_EVERY_ROW | Core.SORT_ASCENDING);
+
+        truth = new Mat(3, 3, CvType.CV_32SC1) {
+            {
+                put(0, 0, 1, 2, 0);
+                put(1, 0, 0, 2, 1);
+                put(2, 0, 0, 1, 2);
+            }
+        };
+        assertMatEqual(truth, b);
+    }
+
+    public void testSplit() {
+        Mat m = getMat(CvType.CV_8UC3, 1, 2, 3);
+        ArrayList<Mat> cois = new ArrayList<Mat>();
+
+        Core.split(m, cois);
+
+        assertMatEqual(gray1, cois.get(0));
+        assertMatEqual(gray2, cois.get(1));
+        assertMatEqual(gray3, cois.get(2));
+    }
+
+    public void testSqrt() {
+        Core.sqrt(gray9_32f, dst);
+
+        assertMatEqual(gray3_32f, dst, EPS);
+
+        Mat rgba144 = new Mat(matSize, matSize, CvType.CV_32FC4, Scalar.all(144));
+        Mat rgba12 = new Mat(matSize, matSize, CvType.CV_32FC4, Scalar.all(12));
+
+        Core.sqrt(rgba144, dst);
+
+        assertMatEqual(rgba12, dst, EPS);
+    }
+
+    public void testSubtractMatMatMat() {
+        Core.subtract(gray128, gray1, dst);
+
+        assertMatEqual(gray127, dst);
+    }
+
+    public void testSubtractMatMatMatMat() {
+        Mat mask = makeMask(gray1.clone());
+        dst = gray128.clone();
+
+        Core.subtract(gray128, gray1, dst, mask);
+
+        assertMatEqual(makeMask(gray127, 128), dst);
+    }
+
+    public void testSubtractMatMatMatMatInt() {
+        Core.subtract(gray3, gray2, dst, gray1, CvType.CV_32F);
+
+        assertMatEqual(gray1_32f, dst, EPS);
+    }
+
+    public void testSumElems() {
+        Mat src = new Mat(4, 4, CvType.CV_8U, new Scalar(10));
+
+        Scalar res1 = Core.sumElems(src);
+
+        assertScalarEqual(new Scalar(160), res1, EPS);
+    }
+
+    public void testSVBackSubst() {
+        Mat w = new Mat(2, 2, CvType.CV_32FC1, new Scalar(2));
+        Mat u = new Mat(2, 2, CvType.CV_32FC1, new Scalar(4));
+        Mat vt = new Mat(2, 2, CvType.CV_32FC1, new Scalar(2));
+        Mat rhs = new Mat(2, 2, CvType.CV_32FC1, new Scalar(1));
+
+        Core.SVBackSubst(w, u, vt, rhs, dst);
+
+        Mat truth = new Mat(2, 2, CvType.CV_32FC1, new Scalar(16));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testSVDecompMatMatMatMat() {
+        Mat src = new Mat(1, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1, 4, 8, 6);
+            }
+        };
+        Mat w = new Mat();
+        Mat u = new Mat();
+        Mat vt = new Mat();
+
+        Core.SVDecomp(src, w, u, vt);
+
+        Mat truthW = new Mat(1, 1, CvType.CV_32FC1, new Scalar(10.816654));
+        Mat truthU = new Mat(1, 1, CvType.CV_32FC1, new Scalar(1));
+        Mat truthVT = new Mat(1, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0.09245003, 0.36980012, 0.73960024, 0.5547002);
+            }
+        };
+        assertMatEqual(truthW, w, EPS);
+        assertMatEqual(truthU, u, EPS);
+        assertMatEqual(truthVT, vt, EPS);
+    }
+
+    public void testSVDecompMatMatMatMatInt() {
+        Mat src = new Mat(1, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1, 4, 8, 6);
+            }
+        };
+        Mat w = new Mat();
+        Mat u = new Mat();
+        Mat vt = new Mat();
+
+        Core.SVDecomp(src, w, u, vt, Core.SVD_NO_UV);
+
+        Mat truthW = new Mat(1, 1, CvType.CV_32FC1, new Scalar(10.816654));
+        assertMatEqual(truthW, w, EPS);
+        assertTrue(u.empty());
+        assertTrue(vt.empty());
+    }
+
+    public void testTrace() {
+        Scalar s = Core.trace(gray1);
+
+        assertEquals(new Scalar(matSize), s);
+    }
+
+    public void testTransform() {
+        Mat src = new Mat(2, 2, CvType.CV_32F, new Scalar(55));
+        Mat m = Mat.eye(2, 2, CvType.CV_32FC1);
+
+        Core.transform(src, dst, m);
+
+        truth = new Mat(2, 2, CvType.CV_32FC2, new Scalar(55, 1));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testTranspose() {
+        gray0.submat(0, gray0.rows() / 2, 0, gray0.cols()).setTo(new Scalar(1));
+        Mat destination = getMat(CvType.CV_8U, 0);
+
+        Core.transpose(gray0, destination);
+
+        Mat subdst = destination.submat(0, destination.rows(), 0, destination.cols() / 2);
+        assertTrue(subdst.total() == Core.countNonZero(subdst));
+    }
+
+    public void testVconcat() {
+        List<Mat> mats = Arrays.asList(Mat.eye(3, 3, CvType.CV_8U), Mat.zeros(2, 3, CvType.CV_8U));
+
+        Core.vconcat(mats, dst);
+
+        assertMatEqual(Mat.eye(5, 3, CvType.CV_8U), dst);
+
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/CvTypeTest.java b/modules/java/android_test/src/org/opencv/test/core/CvTypeTest.java
new file mode 100644
index 0000000000..fc3b5aca8d
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/CvTypeTest.java
@@ -0,0 +1,63 @@
+package org.opencv.test.core;
+
+import org.opencv.core.CvType;
+import org.opencv.test.OpenCVTestCase;
+
+public class CvTypeTest extends OpenCVTestCase {
+
+    public void testMakeType() {
+        assertEquals(CvType.CV_8UC4, CvType.makeType(CvType.CV_8U, 4));
+    }
+
+    public void testCV_8UC() {
+        assertEquals(CvType.CV_8UC4, CvType.CV_8UC(4));
+    }
+
+    public void testCV_8SC() {
+        assertEquals(CvType.CV_8SC4, CvType.CV_8SC(4));
+    }
+
+    public void testCV_16UC() {
+        assertEquals(CvType.CV_16UC4, CvType.CV_16UC(4));
+    }
+
+    public void testCV_16SC() {
+        assertEquals(CvType.CV_16SC4, CvType.CV_16SC(4));
+    }
+
+    public void testCV_32SC() {
+        assertEquals(CvType.CV_32SC4, CvType.CV_32SC(4));
+    }
+
+    public void testCV_32FC() {
+        assertEquals(CvType.CV_32FC4, CvType.CV_32FC(4));
+    }
+
+    public void testCV_64FC() {
+        assertEquals(CvType.CV_64FC4, CvType.CV_64FC(4));
+    }
+
+    public void testChannels() {
+        assertEquals(1, CvType.channels(CvType.CV_64F));
+    }
+
+    public void testDepth() {
+        assertEquals(CvType.CV_64F, CvType.depth(CvType.CV_64FC3));
+    }
+
+    public void testIsInteger() {
+        assertFalse(CvType.isInteger(CvType.CV_32FC3));
+        assertTrue(CvType.isInteger(CvType.CV_16S));
+    }
+
+    public void testELEM_SIZE() {
+        assertEquals(3 * 8, CvType.ELEM_SIZE(CvType.CV_64FC3));
+    }
+
+    public void testTypeToString() {
+        assertEquals("CV_32FC1", CvType.typeToString(CvType.CV_32F));
+        assertEquals("CV_32FC3", CvType.typeToString(CvType.CV_32FC3));
+        assertEquals("CV_32FC(128)", CvType.typeToString(CvType.CV_32FC(128)));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/MatTest.java b/modules/java/android_test/src/org/opencv/test/core/MatTest.java
new file mode 100644
index 0000000000..ed0623b238
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/MatTest.java
@@ -0,0 +1,801 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Range;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+import java.util.Arrays;
+
+public class MatTest extends OpenCVTestCase {
+
+    public void testAdjustROI() {
+        Mat roi = gray0.submat(3, 5, 7, 10);
+        Mat originalroi = roi.clone();
+
+        Mat adjusted = roi.adjustROI(2, 2, 2, 2);
+
+        assertMatEqual(adjusted, roi);
+        assertSizeEquals(new Size(5, 6), adjusted.size(), EPS);
+        assertEquals(originalroi.type(), adjusted.type());
+        assertTrue(adjusted.isSubmatrix());
+        assertFalse(adjusted.isContinuous());
+
+        Point offset = new Point();
+        Size size = new Size();
+        adjusted.locateROI(size, offset);
+        assertPointEquals(new Point(5, 1), offset, EPS);
+        assertSizeEquals(gray0.size(), size, EPS);
+    }
+
+    public void testAssignToMat() {
+        gray0.assignTo(dst);
+
+        assertMatEqual(gray0, dst);
+
+        gray255.assignTo(dst);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testAssignToMatInt() {
+        gray255.assignTo(dst, CvType.CV_32F);
+
+        assertMatEqual(gray255_32f, dst, EPS);
+    }
+
+    public void testChannels() {
+        assertEquals(1, gray0.channels());
+        assertEquals(3, rgbLena.channels());
+        assertEquals(4, rgba0.channels());
+    }
+
+    public void testCheckVectorInt() {
+        // ! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel
+        // (1 x N) or (N x 1); negative number otherwise
+        assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10));
+        assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10));
+        assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10));
+        assertEquals(2, new Mat(1, 10, CvType.CV_8UC2).checkVector(10));
+
+        assertTrue(0 > new Mat().checkVector(0));
+        assertTrue(0 > new Mat(10, 1, CvType.CV_8U).checkVector(10));
+        assertTrue(0 > new Mat(10, 20, CvType.CV_8U).checkVector(10));
+    }
+
+    public void testCheckVectorIntInt() {
+        assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8U));
+        assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U));
+        assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U));
+        assertEquals(2, new Mat(1, 10, CvType.CV_8UC2).checkVector(10, CvType.CV_8U));
+
+        assertTrue(0 > new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8S));
+        assertTrue(0 > new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S));
+        assertTrue(0 > new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S));
+        assertTrue(0 > new Mat(1, 10, CvType.CV_8UC2).checkVector(10, CvType.CV_8S));
+    }
+
+    public void testCheckVectorIntIntBoolean() {
+        Mat mm = new Mat(5, 1, CvType.CV_8UC(10));
+        Mat roi = new Mat(5, 3, CvType.CV_8UC(10)).submat(1, 3, 2, 3);
+
+        assertEquals(5, mm.checkVector(10, CvType.CV_8U, true));
+        assertEquals(5, mm.checkVector(10, CvType.CV_8U, false));
+        assertEquals(2, roi.checkVector(10, CvType.CV_8U, false));
+        assertTrue(0 > roi.checkVector(10, CvType.CV_8U, true));
+    }
+
+    public void testClone() {
+        dst = gray0.clone();
+        assertMatEqual(gray0, dst);
+        assertFalse(gray0.getNativeObjAddr() == dst.getNativeObjAddr());
+        assertFalse(gray0.dataAddr() == dst.dataAddr());
+    }
+
+    public void testCol() {
+        Mat col = gray0.col(0);
+        assertEquals(1, col.cols());
+        assertEquals(gray0.rows(), col.rows());
+    }
+
+    public void testColRangeIntInt() {
+        Mat cols = gray0.colRange(0, gray0.cols() / 2);
+
+        assertEquals(gray0.cols() / 2, cols.cols());
+        assertEquals(gray0.rows(), cols.rows());
+    }
+
+    public void testColRangeRange() {
+        Range range = new Range(0, 5);
+        dst = gray0.colRange(range);
+
+        truth = new Mat(10, 5, CvType.CV_8UC1, new Scalar(0.0));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testCols() {
+        assertEquals(matSize, gray0.cols());
+    }
+
+    public void testConvertToMatInt() {
+        gray255.convertTo(dst, CvType.CV_32F);
+
+        truth = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(255));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testConvertToMatIntDouble() {
+        gray2.convertTo(dst, CvType.CV_16U, 2.0);
+
+        truth = new Mat(matSize, matSize, CvType.CV_16U, new Scalar(4));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testConvertToMatIntDoubleDouble() {
+        gray0_32f.convertTo(dst, CvType.CV_8U, 2.0, 4.0);
+
+        truth = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(4));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testCopyToMat() {
+        rgbLena.copyTo(dst);
+        assertMatEqual(rgbLena, dst);
+    }
+
+    public void testCopyToMatMat() {
+        Mat src = new Mat(4, 4, CvType.CV_8U, new Scalar(5));
+        Mat mask = makeMask(src.clone());
+
+        src.copyTo(dst, mask);
+
+        truth = new Mat(4, 4, CvType.CV_8U) {
+            {
+                put(0, 0, 0, 0, 5, 5);
+                put(1, 0, 0, 0, 5, 5);
+                put(2, 0, 0, 0, 5, 5);
+                put(3, 0, 0, 0, 5, 5);
+            }
+        };
+        assertMatEqual(truth, dst);
+
+    }
+
+    public void testCreateIntIntInt() {
+        gray255.create(4, 5, CvType.CV_32F);
+
+        assertEquals(4, gray255.rows());
+        assertEquals(5, gray255.cols());
+        assertEquals(CvType.CV_32F, gray255.type());
+    }
+
+    public void testCreateSizeInt() {
+        Size size = new Size(5, 5);
+        dst.create(size, CvType.CV_16U);
+
+        assertEquals(5, dst.rows());
+        assertEquals(5, dst.cols());
+        assertEquals(CvType.CV_16U, dst.type());
+    }
+
+    public void testCross() {
+        Mat answer = new Mat(1, 3, CvType.CV_32F);
+        answer.put(0, 0, 7.0, 1.0, -5.0);
+
+        Mat cross = v1.cross(v2);
+        assertMatEqual(answer, cross, EPS);
+    }
+
+    public void testDataAddr() {
+        assertTrue(0 != gray0.dataAddr());
+        assertEquals(0, new Mat().dataAddr());
+    }
+
+    public void testDepth() {
+        assertEquals(CvType.CV_8U, gray0.depth());
+        assertEquals(CvType.CV_32F, gray0_32f.depth());
+    }
+
+    public void testDiag() {
+        dst = gray0.diag();
+
+        truth = new Mat(10, 1, CvType.CV_8UC1, new Scalar(0));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testDiagInt() {
+        dst = gray255.diag(2);
+
+        truth = new Mat(8, 1, CvType.CV_8UC1, new Scalar(255));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testDiagMat() {
+        Mat diagVector = new Mat(matSize, 1, CvType.CV_32F, new Scalar(1));
+
+        dst = Mat.diag(diagVector);
+
+        assertMatEqual(grayE_32f, dst, EPS);
+    }
+
+    public void testDiagMat_sqrMatrix() {
+        try {
+            dst = Mat.diag(gray255);
+        } catch (CvException e) {
+            // expected
+        }
+    }
+
+    public void testDot() {
+        double s = v1.dot(v2);
+        assertEquals(11.0, s);
+    }
+
+    public void testDump() {
+        assertEquals("[1, 3, 2]", v1.dump());
+    }
+
+    public void testElemSize() {
+        assertEquals(Byte.SIZE / 8 * gray0.channels(), gray0.elemSize());
+        assertEquals(Float.SIZE / 8 * gray0_32f.channels(), gray0_32f.elemSize());
+        assertEquals(Byte.SIZE / 8 * rgbLena.channels(), rgbLena.elemSize());
+    }
+
+    public void testElemSize1() {
+        assertEquals(Byte.SIZE / 8, gray255.elemSize1());
+        assertEquals(Double.SIZE / 8, gray0_64f.elemSize1());
+        assertEquals(Byte.SIZE / 8, rgbLena.elemSize1());
+    }
+
+    public void testEmpty() {
+        assertTrue(dst.empty());
+        assertTrue(!gray0.empty());
+    }
+
+    public void testEyeIntIntInt() {
+        Mat eye = Mat.eye(3, 3, CvType.CV_32FC1);
+
+        assertMatEqual(eye, eye.inv(), EPS);
+    }
+
+    public void testEyeSizeInt() {
+        Size size = new Size(5, 5);
+
+        Mat eye = Mat.eye(size, CvType.CV_32S);
+
+        assertEquals(5, Core.countNonZero(eye));
+
+    }
+
+    public void testGetIntInt() {
+        Mat src = new Mat(3, 3, CvType.CV_8U, new Scalar(2));
+        double[] actualArray = src.get(1, 1);
+
+        assertTrue(Arrays.equals(new double[] { 2 }, actualArray));
+    }
+
+    public void testGetIntIntByteArray() {
+        Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
+        byte[] goodData = new byte[9];
+        byte[] badData = new byte[7];
+        m.get(1, 1, goodData);
+
+        assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 }, goodData));
+
+        try {
+            m.get(2, 2, badData);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testGetIntIntDoubleArray() {
+        Mat src = new Mat(2, 2, CvType.CV_64F);
+        double[] doubleArray = { 1.0, 2.0, 3.0 };
+
+        int numOfBytes = src.get(0, 0, doubleArray);
+        assertEquals(24, numOfBytes);
+    }
+
+    public void testGetIntIntFloatArray() {
+        Mat src = new Mat(2, 2, CvType.CV_32F);
+        float[] floatArray = { 3.0f, 1.0f, 4.0f };
+
+        int numOfBytes = src.get(0, 0, floatArray);
+        assertEquals(12, numOfBytes);
+    }
+
+    public void testGetIntIntIntArray() {
+        Mat src = new Mat(2, 2, CvType.CV_32S);
+        int[] intArray = { 3, 1, 4, 7 };
+
+        int numOfBytes = src.get(0, 0, intArray);
+        assertEquals(16, numOfBytes);
+    }
+
+    public void testGetIntIntShortArray() {
+        Mat src = new Mat(2, 2, CvType.CV_16U);
+        short[] data = { 3, 1, 4, 7 };
+
+        int numOfBytes = src.get(1, 1, data);
+        assertEquals(2, numOfBytes);
+    }
+
+    public void testGetNativeObjAddr() {
+        assertTrue(0 != gray0.getNativeObjAddr());
+    }
+
+    public void testHeight() {
+        assertEquals(gray0.rows(), gray0.height());
+        assertEquals(rgbLena.rows(), rgbLena.height());
+        assertEquals(rgba128.rows(), rgba128.height());
+    }
+
+    public void testInv() {
+        dst = grayE_32f.inv();
+        assertMatEqual(grayE_32f, dst, EPS);
+    }
+
+    public void testInvInt() {
+        Mat src = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 1.0);
+                put(0, 1, 2.0);
+                put(1, 0, 1.5);
+                put(1, 1, 4.0);
+            }
+        };
+
+        dst = src.inv(Core.DECOMP_CHOLESKY);
+
+        truth = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 4.0);
+                put(0, 1, -2.0);
+                put(1, 0, -1.5);
+                put(1, 1, 1.0);
+            }
+        };
+
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIsContinuous() {
+        assertTrue(gray0.isContinuous());
+
+        Mat subMat = gray0.submat(0, 0, gray0.rows() / 2, gray0.cols() / 2);
+        assertFalse(subMat.isContinuous());
+    }
+
+    public void testIsSubmatrix() {
+        assertFalse(gray0.isSubmatrix());
+        Mat subMat = gray0.submat(0, 0, gray0.rows() / 2, gray0.cols() / 2);
+        assertTrue(subMat.isSubmatrix());
+    }
+
+    public void testLocateROI() {
+        Mat roi = gray0.submat(3, 5, 7, 10);
+        Point offset = new Point();
+        Size size = new Size();
+
+        roi.locateROI(size, offset);
+
+        assertPointEquals(new Point(7, 3), offset, EPS);
+        assertSizeEquals(new Size(10, 10), size, EPS);
+    }
+
+    public void testMat() {
+        Mat m = new Mat();
+        assertNotNull(m);
+        assertTrue(m.empty());
+    }
+
+    public void testMatIntIntCvType() {
+        Mat gray = new Mat(1, 1, CvType.CV_8UC1);
+        assertFalse(gray.empty());
+
+        Mat rgb = new Mat(1, 1, CvType.CV_8UC3);
+        assertFalse(rgb.empty());
+    }
+
+    public void testMatIntIntCvTypeScalar() {
+        dst = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));
+        assertFalse(dst.empty());
+        assertMatEqual(dst, gray127);
+
+        dst = new Mat(rgba128.rows(), rgba128.cols(), CvType.CV_8UC4, Scalar.all(128));
+        assertFalse(dst.empty());
+        assertMatEqual(dst, rgba128);
+    }
+
+    public void testMatIntIntInt() {
+        Mat gray = new Mat(1, 1, CvType.CV_8U);
+        assertFalse(gray.empty());
+
+        Mat rgb = new Mat(1, 1, CvType.CV_8U);
+        assertFalse(rgb.empty());
+    }
+
+    public void testMatIntIntIntScalar() {
+        Mat m1 = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));
+        assertFalse(m1.empty());
+        assertMatEqual(m1, gray127);
+
+        Mat m2 = new Mat(gray0_32f.rows(), gray0_32f.cols(), CvType.CV_32F, new Scalar(0));
+        assertFalse(m2.empty());
+        assertMatEqual(m2, gray0_32f, EPS);
+    }
+
+    public void testMatMatRange() {
+        dst = new Mat(gray0, new Range(0, 5));
+
+        truth = new Mat(5, 10, CvType.CV_8UC1, new Scalar(0));
+        assertFalse(dst.empty());
+        assertMatEqual(truth, dst);
+    }
+
+    public void testMatMatRangeRange() {
+        dst = new Mat(gray255_32f, new Range(0, 5), new Range(0, 5));
+
+        truth = new Mat(5, 5, CvType.CV_32FC1, new Scalar(255));
+
+        assertFalse(dst.empty());
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMatMatRect() {
+        dst = new Mat(gray255_32f, new Rect(2, 2, 7, 7));
+
+        truth = new Mat(7, 7, CvType.CV_32FC1, new Scalar(255));
+
+        assertFalse(dst.empty());
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMatSizeInt() {
+        dst = new Mat(new Size(10, 10), CvType.CV_8U);
+
+        assertFalse(dst.empty());
+    }
+
+    public void testMatSizeIntScalar() {
+        dst = new Mat(new Size(10, 10), CvType.CV_32F, new Scalar(255));
+
+        assertFalse(dst.empty());
+        assertMatEqual(gray255_32f, dst, EPS);
+    }
+
+    public void testMulMat() {
+        assertMatEqual(gray0, gray0.mul(gray255));
+
+        Mat m1 = new Mat(2, 2, CvType.CV_32F, new Scalar(2));
+        Mat m2 = new Mat(2, 2, CvType.CV_32F, new Scalar(3));
+
+        dst = m1.mul(m2);
+
+        truth = new Mat(2, 2, CvType.CV_32F, new Scalar(6));
+        assertMatEqual(truth, dst, EPS);
+
+    }
+
+    public void testMulMatDouble() {
+        Mat m1 = new Mat(2, 2, CvType.CV_32F, new Scalar(2));
+        Mat m2 = new Mat(2, 2, CvType.CV_32F, new Scalar(3));
+
+        dst = m1.mul(m2, 3.0);
+
+        truth = new Mat(2, 2, CvType.CV_32F, new Scalar(18));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testOnesIntIntInt() {
+        dst = Mat.ones(matSize, matSize, CvType.CV_32F);
+
+        truth = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(1));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testOnesSizeInt() {
+        dst = Mat.ones(new Size(2, 2), CvType.CV_16S);
+        truth = new Mat(2, 2, CvType.CV_16S, new Scalar(1));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testPush_back() {
+        Mat m1 = new Mat(2, 4, CvType.CV_32F, new Scalar(2));
+        Mat m2 = new Mat(3, 4, CvType.CV_32F, new Scalar(3));
+
+        m1.push_back(m2);
+
+        truth = new Mat(5, 4, CvType.CV_32FC1) {
+            {
+                put(0, 0, 2, 2, 2, 2);
+                put(1, 0, 2, 2, 2, 2);
+                put(2, 0, 3, 3, 3, 3);
+                put(3, 0, 3, 3, 3, 3);
+                put(4, 0, 3, 3, 3, 3);
+            }
+        };
+
+        assertMatEqual(truth, m1, EPS);
+    }
+
+    public void testPutIntIntByteArray() {
+        Mat m = new Mat(5, 5, CvType.CV_8UC3);
+        byte[] bytes = new byte[] { 10, 20, 30, 40, 50, 60 };
+        m.put(1, 1, bytes);
+
+        try {
+            byte[] bytes2 = new byte[] { 10, 20, 30, 40, 50 };
+            m.put(2, 2, bytes2);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testPutIntIntDoubleArray() {
+        Mat m = new Mat(5, 5, CvType.CV_8UC3);
+        m.put(1, 1, 10, 20, 30, 40, 50, 60);
+
+        try {
+            m.put(2, 2, 11, 22, 33, 44, 55);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testPutIntIntFloatArray() {
+        Mat m = new Mat(5, 5, CvType.CV_32FC3);
+        float[] elements = new float[] { 10, 20, 30, 40, 50, 60 };
+        m.put(1, 1, elements);
+
+        try {
+            float[] elements2 = new float[] { 10, 20, 30, 40, 50 };
+            m.put(2, 2, elements2);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testPutIntIntIntArray() {
+        Mat m = new Mat(5, 5, CvType.CV_32SC3);
+        int[] elements = new int[] { 10, 20, 30, 40, 50, 60 };
+        m.put(1, 1, elements);
+
+        try {
+            int[] elements2 = new int[] { 10, 20, 30, 40, 50 };
+            m.put(2, 2, elements2);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testPutIntIntShortArray() {
+        Mat m = new Mat(5, 5, CvType.CV_16SC3);
+        short[] elements = new short[] { 10, 20, 30, 40, 50, 60 };
+        m.put(1, 1, elements);
+
+        try {
+            short[] elements2 = new short[] { 10, 20, 30, 40, 50 };
+            m.put(2, 2, elements2);
+            fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    public void testRelease() {
+        assertFalse(gray0.empty());
+        assertTrue(gray0.rows() > 0);
+
+        gray0.release();
+
+        assertTrue(gray0.empty());
+        assertEquals(0, gray0.rows());
+        assertEquals(0, gray0.dataAddr());
+    }
+
+    public void testReshapeInt() {
+        Mat src = new Mat(4, 4, CvType.CV_8U, new Scalar(0));
+        dst = src.reshape(4);
+
+        truth = new Mat(4, 1, CvType.CV_8UC4, new Scalar(0));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testReshapeIntInt() {
+        Mat src = new Mat(5, 7, CvType.CV_8U, new Scalar(0));
+        dst = src.reshape(7, 5);
+
+        truth = new Mat(5, 1, CvType.CV_8UC(7), new Scalar(0));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testRow() {
+        Mat row = gray0.row(0);
+        assertEquals(1, row.rows());
+        assertEquals(gray0.cols(), row.cols());
+    }
+
+    public void testRowRangeIntInt() {
+        Mat rows = gray0.rowRange(0, gray0.rows() / 2);
+        assertEquals(gray0.rows() / 2, rows.rows());
+        assertEquals(gray0.cols(), rows.cols());
+    }
+
+    public void testRowRangeRange() {
+        Mat rows = gray255.rowRange(new Range(0, 5));
+
+        assertEquals(gray255.rows() / 2, rows.rows());
+        assertEquals(gray255.cols(), rows.cols());
+    }
+
+    public void testRows() {
+        assertEquals(matSize, gray0.rows());
+    }
+
+    public void testSetToMat() {
+        Mat vals = new Mat(7, 1, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 2, 3, 4, 5, 6, 7);
+            }
+        };
+        Mat dst = new Mat(1, 1, CvType.CV_8UC(7));
+
+        dst.setTo(vals);
+
+        Mat truth = new Mat(1, 1, CvType.CV_8UC(7)) {
+            {
+                put(0, 0, 1, 2, 3, 4, 5, 6, 7);
+            }
+        };
+        assertMatEqual(truth, dst);
+    }
+
+    public void testSetToMatMat() {
+        Mat vals = new Mat(7, 1, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 2, 3, 4, 5, 6, 7);
+            }
+        };
+        Mat dst = Mat.zeros(2, 1, CvType.CV_8UC(7));
+        Mat mask = new Mat(2, 1, CvType.CV_8U) {
+            {
+                put(0, 0, 0, 1);
+            }
+        };
+
+        dst.setTo(vals, mask);
+
+        Mat truth = new Mat(2, 1, CvType.CV_8UC(7)) {
+            {
+                put(0, 0, 0, 0, 0, 0, 0, 0, 0);
+                put(1, 0, 1, 2, 3, 4, 5, 6, 7);
+            }
+        };
+        assertMatEqual(truth, dst);
+    }
+
+    public void testSetToScalar() {
+        gray0.setTo(new Scalar(127));
+        assertMatEqual(gray127, gray0);
+    }
+
+    public void testSize() {
+        assertEquals(new Size(matSize, matSize), gray0.size());
+
+        assertEquals(new Size(3, 1), v1.size());
+    }
+
+    public void testStep1() {
+        assertEquals(matSize * CvType.channels(CvType.CV_8U), gray0.step1());
+
+        assertEquals(3, v2.step1());
+    }
+
+    public void testStep1Int() {
+        Mat roi = rgba0.submat(3, 5, 7, 10);
+        Mat m = roi.clone();
+
+        assertEquals(rgba0.channels() * rgba0.cols(), roi.step1(0));
+        assertEquals(rgba0.channels(), roi.step1(1));
+        assertEquals(rgba0.channels() * (10 - 7), m.step1(0));
+        assertEquals(rgba0.channels(), m.step1(1));
+    }
+
+    public void testSubmatIntIntIntInt() {
+        Mat submat = gray0.submat(0, gray0.rows() / 2, 0, gray0.cols() / 2);
+
+        assertTrue(submat.isSubmatrix());
+        assertFalse(submat.isContinuous());
+        assertEquals(gray0.rows() / 2, submat.rows());
+        assertEquals(gray0.cols() / 2, submat.cols());
+    }
+
+    public void testSubmatRangeRange() {
+        Mat submat = gray255.submat(new Range(2, 4), new Range(2, 4));
+        assertTrue(submat.isSubmatrix());
+        assertFalse(submat.isContinuous());
+
+        assertEquals(2, submat.rows());
+        assertEquals(2, submat.cols());
+    }
+
+    public void testSubmatRect() {
+        Mat submat = gray255.submat(new Rect(5, gray255.rows() / 2, 5, gray255.cols() / 2));
+        assertTrue(submat.isSubmatrix());
+        assertFalse(submat.isContinuous());
+
+        assertEquals(gray255.rows() / 2, submat.rows());
+        assertEquals(gray255.cols() / 2, submat.cols());
+    }
+
+    public void testT() {
+        assertMatEqual(gray255, gray255.t());
+
+        Mat src = new Mat(3, 3, CvType.CV_16U) {
+            {
+                put(0, 0, 1, 2, 4);
+                put(1, 0, 7, 5, 0);
+                put(2, 0, 3, 4, 6);
+            }
+        };
+
+        dst = src.t();
+
+        truth = new Mat(3, 3, CvType.CV_16U) {
+            {
+                put(0, 0, 1, 7, 3);
+                put(1, 0, 2, 5, 4);
+                put(2, 0, 4, 0, 6);
+            }
+        };
+        assertMatEqual(truth, dst);
+    }
+
+    public void testToString() {
+        assertTrue(null != gray0.toString());
+    }
+
+    public void testTotal() {
+        int nElements = gray0.rows() * gray0.cols();
+        assertEquals(nElements, gray0.total());
+    }
+
+    public void testType() {
+        assertEquals(CvType.CV_8UC1, gray0.type());
+        assertEquals(CvType.CV_32FC1, gray0_32f.type());
+        assertEquals(CvType.CV_8UC3, rgbLena.type());
+    }
+
+    public void testWidth() {
+        assertEquals(gray0.cols(), gray0.width());
+        assertEquals(rgbLena.cols(), rgbLena.width());
+        assertEquals(rgba128.cols(), rgba128.width());
+    }
+
+    public void testZerosIntIntInt() {
+        dst = Mat.zeros(matSize, matSize, CvType.CV_32F);
+
+        assertMatEqual(gray0_32f, dst, EPS);
+    }
+
+    public void testZerosSizeInt() {
+        dst = Mat.zeros(new Size(2, 2), CvType.CV_16S);
+
+        truth = new Mat(2, 2, CvType.CV_16S, new Scalar(0));
+        assertMatEqual(truth, dst);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/Point3Test.java b/modules/java/android_test/src/org/opencv/test/core/Point3Test.java
new file mode 100644
index 0000000000..4f6565eb5e
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/Point3Test.java
@@ -0,0 +1,107 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.test.OpenCVTestCase;
+
+public class Point3Test extends OpenCVTestCase {
+
+    private Point3 p1;
+    private Point3 p2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        p1 = new Point3(2, 2, 2);
+        p2 = new Point3(1, 1, 1);
+    }
+
+    public void testClone() {
+        Point3 truth = new Point3(1, 1, 1);
+        p1 = truth.clone();
+        assertEquals(truth, p1);
+    }
+
+    public void testCross() {
+        Point3 dstPoint = p1.cross(p2);
+        Point3 truth = new Point3(0, 0, 0);
+        assertEquals(truth, dstPoint);
+    }
+
+    public void testDot() {
+        double result = p1.dot(p2);
+        assertEquals(6.0, result);
+    }
+
+    public void testEqualsObject() {
+        boolean flag = p1.equals(p1);
+        assertTrue(flag);
+
+        flag = p1.equals(p2);
+        assertFalse(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(p1.hashCode(), p1.hashCode());
+    }
+
+    public void testPoint3() {
+        p1 = new Point3();
+
+        assertNotNull(p1);
+        assertTrue(0 == p1.x);
+        assertTrue(0 == p1.y);
+        assertTrue(0 == p1.z);
+    }
+
+    public void testPoint3DoubleArray() {
+        double[] vals = { 1, 2, 3 };
+        p1 = new Point3(vals);
+
+        assertTrue(1 == p1.x);
+        assertTrue(2 == p1.y);
+        assertTrue(3 == p1.z);
+    }
+
+    public void testPoint3DoubleDoubleDouble() {
+        p1 = new Point3(1, 2, 3);
+
+        assertEquals(1., p1.x);
+        assertEquals(2., p1.y);
+        assertEquals(3., p1.z);
+    }
+
+    public void testPoint3Point() {
+        Point p = new Point(2, 3);
+        p1 = new Point3(p);
+
+        assertEquals(2., p1.x);
+        assertEquals(3., p1.y);
+        assertEquals(0., p1.z);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        p1.set(vals1);
+
+        assertEquals(0., p1.x);
+        assertEquals(0., p1.y);
+        assertEquals(0., p1.z);
+
+        double[] vals2 = { 3, 6, 10 };
+        p1.set(vals2);
+
+        assertEquals(3., p1.x);
+        assertEquals(6., p1.y);
+        assertEquals(10., p1.z);
+    }
+    
+    public void testToString() {
+        String actual = p1.toString();
+        String expected = "{2.0, 2.0, 2.0}";
+        assertEquals(expected, actual);
+    }
+
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/PointTest.java b/modules/java/android_test/src/org/opencv/test/core/PointTest.java
new file mode 100644
index 0000000000..877cc1d89c
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/PointTest.java
@@ -0,0 +1,93 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.test.OpenCVTestCase;
+
+public class PointTest extends OpenCVTestCase {
+
+    private Point p1;
+    private Point p2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        p1 = new Point(2, 2);
+        p2 = new Point(1, 1);
+    }
+
+    public void testClone() {
+        Point truth = new Point(1, 1);
+        Point dstPoint = truth.clone();
+        assertEquals(truth, dstPoint);
+    }
+
+    public void testDot() {
+        double result = p1.dot(p2);
+        assertEquals(4.0, result);
+    }
+
+    public void testEqualsObject() {
+        boolean flag = p1.equals(p1);
+        assertTrue(flag);
+
+        flag = p1.equals(p2);
+        assertFalse(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(p1.hashCode(), p1.hashCode());
+    }
+
+    public void testInside() {
+        Rect rect = new Rect(0, 0, 5, 3);
+        assertTrue(p1.inside(rect));
+
+        Point p2 = new Point(3, 3);
+        assertFalse(p2.inside(rect));
+    }
+
+    public void testPoint() {
+        Point p = new Point();
+
+        assertNotNull(p);
+        assertEquals(0.0, p.x);
+        assertEquals(0.0, p.y);
+    }
+
+    public void testPointDoubleArray() {
+        double[] vals = { 2, 4 };
+        Point p = new Point(vals);
+
+        assertEquals(2.0, p.x);
+        assertEquals(4.0, p.y);
+    }
+
+    public void testPointDoubleDouble() {
+        p1 = new Point(7, 5);
+
+        assertNotNull(p1);
+        assertEquals(7.0, p1.x);
+        assertEquals(5.0, p1.y);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        p1.set(vals1);
+        assertEquals(0.0, p1.x);
+        assertEquals(0.0, p1.y);
+
+        double[] vals2 = { 6, 10 };
+        p2.set(vals2);
+        assertEquals(6.0, p2.x);
+        assertEquals(10.0, p2.y);
+    }
+
+    public void testToString() {
+        String actual = p1.toString();
+        String expected = "{2.0, 2.0}";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/RangeTest.java b/modules/java/android_test/src/org/opencv/test/core/RangeTest.java
new file mode 100644
index 0000000000..6734fbcb3f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/RangeTest.java
@@ -0,0 +1,113 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Range;
+import org.opencv.test.OpenCVTestCase;
+
+public class RangeTest extends OpenCVTestCase {
+
+    Range r1;
+    Range r2;
+    Range range;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        range = new Range();
+        r1 = new Range(1, 11);
+        r2 = new Range(1, 1);
+    }
+
+    public void testAll() {
+        range = Range.all();
+        assertEquals(Integer.MIN_VALUE, range.start);
+        assertEquals(Integer.MAX_VALUE, range.end);
+    }
+
+    public void testClone() {
+        Range dstRange = new Range();
+        dstRange = r1.clone();
+        assertEquals(r1, dstRange);
+    }
+
+    public void testEmpty() {
+        boolean flag;
+
+        flag = r1.empty();
+        assertFalse(flag);
+
+        flag = r2.empty();
+        assertTrue(flag);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(r2.equals(r1));
+
+        range = r1.clone();
+        assertTrue(r1.equals(range));
+    }
+
+    public void testHashCode() {
+        assertEquals(r1.hashCode(), r1.hashCode());
+    }
+
+    public void testIntersection() {
+        range = r1.intersection(r2);
+        assertEquals(r2, range);
+    }
+
+    public void testRange() {
+        range = new Range();
+
+        assertNotNull(range);
+        assertEquals(0, range.start);
+        assertEquals(0, range.end);
+    }
+
+    public void testRangeDoubleArray() {
+        double[] vals = { 2, 4 };
+        Range r = new Range(vals);
+
+        assertTrue(2 == r.start);
+        assertTrue(4 == r.end);
+    }
+
+    public void testRangeIntInt() {
+        r1 = new Range(12, 13);
+
+        assertNotNull(r1);
+        assertEquals(12, r1.start);
+        assertEquals(13, r1.end);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        r1.set(vals1);
+        assertEquals(0, r1.start);
+        assertEquals(0, r1.end);
+
+        double[] vals2 = { 6, 10 };
+        r2.set(vals2);
+        assertEquals(6, r2.start);
+        assertEquals(10, r2.end);
+    }
+
+    public void testShift() {
+        int delta = 1;
+        range = range.shift(delta);
+        assertEquals(r2, range);
+    }
+
+    public void testSize() {
+        assertEquals(10, r1.size());
+
+        assertEquals(0, r2.size());
+    }
+
+    public void testToString() {
+        String actual = r1.toString();
+        String expected = "[1, 11)";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/RectTest.java b/modules/java/android_test/src/org/opencv/test/core/RectTest.java
new file mode 100644
index 0000000000..c12160bdd7
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/RectTest.java
@@ -0,0 +1,163 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class RectTest extends OpenCVTestCase {
+
+    private Rect r;
+    private Rect rect;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        r = new Rect();
+        rect = new Rect(0, 0, 10, 10);
+    }
+
+    public void testArea() {
+        double area;
+        area = rect.area();
+        assertEquals(100.0, area);
+    }
+
+    public void testBr() {
+        Point p_br = new Point();
+        p_br = rect.br();
+        Point truth = new Point(10, 10);
+        assertEquals(truth, p_br);
+    }
+
+    public void testClone() {
+        r = rect.clone();
+        assertEquals(rect, r);
+    }
+
+    public void testContains() {
+        Rect rect = new Rect(0, 0, 10, 10);
+
+        Point p_inner = new Point(5, 5);
+        Point p_outer = new Point(5, 55);
+        Point p_bl = new Point(0, 0);
+        Point p_br = new Point(10, 0);
+        Point p_tl = new Point(0, 10);
+        Point p_tr = new Point(10, 10);
+
+        assertTrue(rect.contains(p_inner));
+        assertTrue(rect.contains(p_bl));
+
+        assertFalse(rect.contains(p_outer));
+        assertFalse(rect.contains(p_br));
+        assertFalse(rect.contains(p_tl));
+        assertFalse(rect.contains(p_tr));
+    }
+
+    public void testEqualsObject() {
+        boolean flag;
+        flag = rect.equals(r);
+        assertFalse(flag);
+
+        r = rect.clone();
+        flag = rect.equals(r);
+        assertTrue(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(rect.hashCode(), rect.hashCode());
+    }
+
+    public void testRect() {
+        r = new Rect();
+
+        assertEquals(0, r.x);
+        assertEquals(0, r.y);
+        assertEquals(0, r.width);
+        assertEquals(0, r.height);
+    }
+
+    public void testRectDoubleArray() {
+        double[] vals = { 1, 3, 5, 2 };
+        r = new Rect(vals);
+
+        assertEquals(1, r.x);
+        assertEquals(3, r.y);
+        assertEquals(5, r.width);
+        assertEquals(2, r.height);
+    }
+
+    public void testRectIntIntIntInt() {
+        r = new Rect(1, 3, 5, 2);
+
+        assertNotNull(rect);
+        assertEquals(0, rect.x);
+        assertEquals(0, rect.y);
+        assertEquals(10, rect.width);
+        assertEquals(10, rect.height);
+    }
+
+    public void testRectPointPoint() {
+        Point p1 = new Point(4, 4);
+        Point p2 = new Point(2, 3);
+
+        r = new Rect(p1, p2);
+        assertNotNull(r);
+        assertEquals(2, r.x);
+        assertEquals(3, r.y);
+        assertEquals(2, r.width);
+        assertEquals(1, r.height);
+    }
+
+    public void testRectPointSize() {
+        Point p1 = new Point(4, 4);
+        Size sz = new Size(3, 1);
+        r = new Rect(p1, sz);
+
+        assertEquals(4, r.x);
+        assertEquals(4, r.y);
+        assertEquals(3, r.width);
+        assertEquals(1, r.height);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        Rect r1 = new Rect(vals1);
+
+        assertEquals(0, r1.x);
+        assertEquals(0, r1.y);
+        assertEquals(0, r1.width);
+        assertEquals(0, r1.height);
+
+        double[] vals2 = { 2, 2, 10, 5 };
+        r = new Rect(vals2);
+
+        assertEquals(2, r.x);
+        assertEquals(2, r.y);
+        assertEquals(10, r.width);
+        assertEquals(5, r.height);
+    }
+
+    public void testSize() {
+        Size s1 = new Size(0, 0);
+        assertEquals(s1, r.size());
+
+        Size s2 = new Size(10, 10);
+        assertEquals(s2, rect.size());
+    }
+
+    public void testTl() {
+        Point p_tl = new Point();
+        p_tl = rect.tl();
+        Point truth = new Point(0, 0);
+        assertEquals(truth, p_tl);
+    }
+
+    public void testToString() {
+        String actual = rect.toString();
+        String expected = "{0, 0, 10x10}";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java b/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java
new file mode 100644
index 0000000000..fc215fc661
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java
@@ -0,0 +1,191 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.RotatedRect;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class RotatedRectTest extends OpenCVTestCase {
+
+    private double angle;
+    private Point center;
+    private Size size;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        center = new Point(matSize / 2, matSize / 2);
+        size = new Size(matSize / 4, matSize / 2);
+        angle = 40;
+    }
+
+    public void testBoundingRect() {
+        size = new Size(matSize / 2, matSize / 2);
+        assertEquals(size.height, size.width);
+        double length = size.height;
+
+        angle = 45;
+        RotatedRect rr = new RotatedRect(center, size, angle);
+
+        Rect r = rr.boundingRect();
+        double halfDiagonal = length * Math.sqrt(2) / 2;
+
+        assertTrue((r.x == Math.floor(center.x - halfDiagonal)) && (r.y == Math.floor(center.y - halfDiagonal)));
+
+        assertTrue((r.br().x >= Math.ceil(center.x + halfDiagonal)) && (r.br().y >= Math.ceil(center.y + halfDiagonal)));
+
+        assertTrue((r.br().x - Math.ceil(center.x + halfDiagonal)) <= 1 && (r.br().y - Math.ceil(center.y + halfDiagonal)) <= 1);
+    }
+
+    public void testClone() {
+        RotatedRect rrect = new RotatedRect(center, size, angle);
+        RotatedRect clone = rrect.clone();
+
+        assertTrue(clone != null);
+        assertTrue(rrect.center.equals(clone.center));
+        assertTrue(rrect.size.equals(clone.size));
+        assertTrue(rrect.angle == clone.angle);
+    }
+
+    public void testEqualsObject() {
+        Point center2 = new Point(matSize / 3, matSize / 1.5);
+        Size size2 = new Size(matSize / 2, matSize / 4);
+        double angle2 = 0;
+
+        RotatedRect rrect1 = new RotatedRect(center, size, angle);
+        RotatedRect rrect2 = new RotatedRect(center2, size2, angle2);
+        RotatedRect rrect3 = rrect1;
+        RotatedRect clone1 = rrect1.clone();
+        RotatedRect clone2 = rrect2.clone();
+
+        assertTrue(rrect1.equals(rrect3));
+        assertTrue(!rrect1.equals(rrect2));
+
+        assertTrue(rrect2.equals(clone2));
+        clone2.angle = 10;
+        assertTrue(!rrect2.equals(clone2));
+
+        assertTrue(rrect1.equals(clone1));
+
+        clone1.center.x += 1;
+        assertTrue(!rrect1.equals(clone1));
+
+        clone1.center.x -= 1;
+        assertTrue(rrect1.equals(clone1));
+
+        clone1.size.width += 1;
+        assertTrue(!rrect1.equals(clone1));
+
+        assertTrue(!rrect1.equals(size));
+    }
+
+    public void testHashCode() {
+        RotatedRect rr = new RotatedRect(center, size, angle);
+        assertEquals(rr.hashCode(), rr.hashCode());
+    }
+
+    public void testPoints() {
+        RotatedRect rrect = new RotatedRect(center, size, angle);
+
+        Point p[] = new Point[4];
+        rrect.points(p);
+
+        boolean is_p0_irrational = (100 * p[0].x != (int) (100 * p[0].x)) && (100 * p[0].y != (int) (100 * p[0].y));
+        boolean is_p1_irrational = (100 * p[1].x != (int) (100 * p[1].x)) && (100 * p[1].y != (int) (100 * p[1].y));
+        boolean is_p2_irrational = (100 * p[2].x != (int) (100 * p[2].x)) && (100 * p[2].y != (int) (100 * p[2].y));
+        boolean is_p3_irrational = (100 * p[3].x != (int) (100 * p[3].x)) && (100 * p[3].y != (int) (100 * p[3].y));
+
+        assertTrue(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational);
+
+        assertTrue("Symmetric points 0 and 2",
+                Math.abs((p[0].x + p[2].x) / 2 - center.x) + Math.abs((p[0].y + p[2].y) / 2 - center.y) < EPS);
+
+        assertTrue("Symmetric points 1 and 3",
+                Math.abs((p[1].x + p[3].x) / 2 - center.x) + Math.abs((p[1].y + p[3].y) / 2 - center.y) < EPS);
+
+        assertTrue("Orthogonal vectors 01 and 12",
+                Math.abs((p[1].x - p[0].x) * (p[2].x - p[1].x) +
+                        (p[1].y - p[0].y) * (p[2].y - p[1].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 12 and 23",
+                Math.abs((p[2].x - p[1].x) * (p[3].x - p[2].x) +
+                        (p[2].y - p[1].y) * (p[3].y - p[2].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 23 and 30",
+                Math.abs((p[3].x - p[2].x) * (p[0].x - p[3].x) +
+                        (p[3].y - p[2].y) * (p[0].y - p[3].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 30 and 01",
+                Math.abs((p[0].x - p[3].x) * (p[1].x - p[0].x) +
+                        (p[0].y - p[3].y) * (p[1].y - p[0].y)) < EPS);
+
+        assertTrue("Length of the vector 01",
+                Math.abs((p[1].x - p[0].x) * (p[1].x - p[0].x) +
+                        (p[1].y - p[0].y) * (p[1].y - p[0].y) - size.height * size.height) < EPS);
+
+        assertTrue("Length of the vector 21",
+                Math.abs((p[1].x - p[2].x) * (p[1].x - p[2].x) +
+                        (p[1].y - p[2].y) * (p[1].y - p[2].y) - size.width * size.width) < EPS);
+
+        assertTrue("Angle of the vector 21 with the axes", Math.abs((p[2].x - p[1].x) / size.width - Math.cos(angle * Math.PI / 180)) < EPS);
+    }
+
+    public void testRotatedRect() {
+        RotatedRect rr = new RotatedRect();
+
+        assertTrue(rr != null);
+        assertTrue(rr.center != null);
+        assertTrue(rr.size != null);
+        assertTrue(rr.angle == 0.0);
+    }
+
+    public void testRotatedRectDoubleArray() {
+        double[] vals = { 1.5, 2.6, 3.7, 4.2, 5.1 };
+        RotatedRect rr = new RotatedRect(vals);
+
+        assertNotNull(rr);
+        assertEquals(1.5, rr.center.x);
+        assertEquals(2.6, rr.center.y);
+        assertEquals(3.7, rr.size.width);
+        assertEquals(4.2, rr.size.height);
+        assertEquals(5.1, rr.angle);
+    }
+
+    public void testRotatedRectPointSizeDouble() {
+        RotatedRect rr = new RotatedRect(center, size, 40);
+
+        assertTrue(rr != null);
+        assertTrue(rr.center != null);
+        assertTrue(rr.size != null);
+        assertTrue(rr.angle == 40.0);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        RotatedRect r1 = new RotatedRect(center, size, 40);
+
+        r1.set(vals1);
+
+        assertEquals(0., r1.angle);
+        assertPointEquals(new Point(0, 0), r1.center, EPS);
+        assertSizeEquals(new Size(0, 0), r1.size, EPS);
+
+        double[] vals2 = { 1, 2, 3, 4, 5 };
+        RotatedRect r2 = new RotatedRect(center, size, 40);
+
+        r2.set(vals2);
+
+        assertEquals(5., r2.angle);
+        assertPointEquals(new Point(1, 2), r2.center, EPS);
+        assertSizeEquals(new Size(3, 4), r2.size, EPS);
+    }
+
+    public void testToString() {
+        String actual = new RotatedRect(new Point(1, 2), new Size(10, 12), 4.5).toString();
+        String expected = "{ {1.0, 2.0} 10x12 * 4.5 }";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/ScalarTest.java b/modules/java/android_test/src/org/opencv/test/core/ScalarTest.java
new file mode 100644
index 0000000000..439614ef09
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/ScalarTest.java
@@ -0,0 +1,110 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Scalar;
+import org.opencv.test.OpenCVTestCase;
+
+public class ScalarTest extends OpenCVTestCase {
+
+    private Scalar dstScalar;
+    private Scalar s1;
+    private Scalar s2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        s1 = new Scalar(1.0);
+        s2 = Scalar.all(1.0);
+        dstScalar = null;
+    }
+
+    public void testAll() {
+        dstScalar = Scalar.all(2.0);
+        Scalar truth = new Scalar(2.0, 2.0, 2.0, 2.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testClone() {
+        dstScalar = s2.clone();
+        assertEquals(s2, dstScalar);
+    }
+
+    public void testConj() {
+        dstScalar = s2.conj();
+        Scalar truth = new Scalar(1, -1, -1, -1);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testEqualsObject() {
+        dstScalar = s2.clone();
+        assertTrue(s2.equals(dstScalar));
+
+        assertFalse(s2.equals(s1));
+    }
+
+    public void testHashCode() {
+        assertEquals(s2.hashCode(), s2.hashCode());
+    }
+
+    public void testIsReal() {
+        assertTrue(s1.isReal());
+
+        assertFalse(s2.isReal());
+    }
+
+    public void testMulScalar() {
+        dstScalar = s2.mul(s1);
+        assertEquals(s1, dstScalar);
+    }
+
+    public void testMulScalarDouble() {
+        double multiplier = 2.0;
+        dstScalar = s2.mul(s1, multiplier);
+        Scalar truth = new Scalar(2);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDouble() {
+        Scalar truth = new Scalar(1);
+        assertEquals(truth, s1);
+    }
+
+    public void testScalarDoubleArray() {
+        double[] vals = { 2.0, 4.0, 5.0, 3.0 };
+        dstScalar = new Scalar(vals);
+
+        Scalar truth = new Scalar(2.0, 4.0, 5.0, 3.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDouble() {
+        dstScalar = new Scalar(2, 5);
+        Scalar truth = new Scalar(2.0, 5.0, 0.0, 0.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDoubleDouble() {
+        dstScalar = new Scalar(2.0, 5.0, 5.0);
+        Scalar truth = new Scalar(2.0, 5.0, 5.0, 0.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDoubleDoubleDouble() {
+        dstScalar = new Scalar(2.0, 5.0, 5.0, 9.0);
+        Scalar truth = new Scalar(2.0, 5.0, 5.0, 9.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testSet() {
+        double[] vals = { 1.0, 1.0, 1.0, 1.0 };
+        s1.set(vals);
+        assertEquals(s2, s1);
+    }
+    
+    public void testToString() {
+        String actual = s2.toString();
+        String expected = "[1.0, 1.0, 1.0, 1.0]";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/SizeTest.java b/modules/java/android_test/src/org/opencv/test/core/SizeTest.java
new file mode 100644
index 0000000000..542c35d26c
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/SizeTest.java
@@ -0,0 +1,93 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class SizeTest extends OpenCVTestCase {
+
+    Size dstSize;
+    Size sz1;
+    Size sz2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        sz1 = new Size(10.0, 10.0);
+        sz2 = new Size(-1, -1);
+        dstSize = null;
+    }
+
+    public void testArea() {
+        double area = sz1.area();
+        assertEquals(100.0, area);
+    }
+
+    public void testClone() {
+        dstSize = sz1.clone();
+        assertEquals(sz1, dstSize);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(sz1.equals(sz2));
+
+        sz2 = sz1.clone();
+        assertTrue(sz1.equals(sz2));
+    }
+
+    public void testHashCode() {
+        assertEquals(sz1.hashCode(), sz1.hashCode());
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        sz2.set(vals1);
+        assertEquals(0., sz2.width);
+        assertEquals(0., sz2.height);
+
+        double[] vals2 = { 9, 12 };
+        sz1.set(vals2);
+        assertEquals(9., sz1.width);
+        assertEquals(12., sz1.height);
+    }
+
+    public void testSize() {
+        dstSize = new Size();
+
+        assertNotNull(dstSize);
+        assertEquals(0., dstSize.width);
+        assertEquals(0., dstSize.height);
+    }
+
+    public void testSizeDoubleArray() {
+        double[] vals = { 10, 20 };
+        sz2 = new Size(vals);
+
+        assertEquals(10., sz2.width);
+        assertEquals(20., sz2.height);
+    }
+
+    public void testSizeDoubleDouble() {
+        assertNotNull(sz1);
+
+        assertEquals(10.0, sz1.width);
+        assertEquals(10.0, sz1.height);
+    }
+
+    public void testSizePoint() {
+        Point p = new Point(2, 4);
+        sz1 = new Size(p);
+
+        assertNotNull(sz1);
+        assertEquals(2.0, sz1.width);
+        assertEquals(4.0, sz1.height);
+    }
+    
+    public void testToString() {
+        String actual = sz1.toString();
+        String expected = "10x10";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/core/TermCriteriaTest.java b/modules/java/android_test/src/org/opencv/test/core/TermCriteriaTest.java
new file mode 100644
index 0000000000..656d76162c
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/core/TermCriteriaTest.java
@@ -0,0 +1,85 @@
+package org.opencv.test.core;
+
+import org.opencv.core.TermCriteria;
+import org.opencv.test.OpenCVTestCase;
+
+public class TermCriteriaTest extends OpenCVTestCase {
+
+    private TermCriteria tc1;
+    private TermCriteria tc2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        tc1 = new TermCriteria();
+        tc2 = new TermCriteria(2, 4, EPS);
+    }
+
+    public void testClone() {
+        tc1 = tc2.clone();
+        assertEquals(tc2, tc1);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(tc2.equals(tc1));
+
+        tc1 = tc2.clone();
+        assertTrue(tc2.equals(tc1));
+    }
+
+    public void testHashCode() {
+        assertEquals(tc2.hashCode(), tc2.hashCode());
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        tc1.set(vals1);
+
+        assertEquals(0, tc1.type);
+        assertEquals(0, tc1.maxCount);
+        assertEquals(0.0, tc1.epsilon);
+
+        double[] vals2 = { 9, 8, 0.002 };
+        tc2.set(vals2);
+
+        assertEquals(9, tc2.type);
+        assertEquals(8, tc2.maxCount);
+        assertEquals(0.002, tc2.epsilon);
+    }
+
+    public void testTermCriteria() {
+        tc1 = new TermCriteria();
+
+        assertNotNull(tc1);
+        assertEquals(0, tc1.type);
+        assertEquals(0, tc1.maxCount);
+        assertEquals(0.0, tc1.epsilon);
+    }
+
+    public void testTermCriteriaDoubleArray() {
+        double[] vals = { 3, 2, 0.007 };
+        tc1 = new TermCriteria(vals);
+
+        assertEquals(3, tc1.type);
+        assertEquals(2, tc1.maxCount);
+        assertEquals(0.007, tc1.epsilon);
+    }
+
+    public void testTermCriteriaIntIntDouble() {
+        tc1 = new TermCriteria(2, 4, EPS);
+
+        assertNotNull(tc2);
+        assertEquals(2, tc2.type);
+        assertEquals(4, tc2.maxCount);
+        assertEquals(EPS, tc2.epsilon);
+    }
+
+    public void testToString() {
+        String actual = tc2.toString();
+        String expected = "{ type: 2, maxCount: 4, epsilon: 0.001}";
+
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BRIEFDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BRIEFDescriptorExtractorTest.java
new file mode 100644
index 0000000000..284981d104
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BRIEFDescriptorExtractorTest.java
@@ -0,0 +1,102 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class BRIEFDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+        matSize = 100;
+
+        super.setUp();
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        List<KeyPoint> keypoints = Arrays.asList(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0, 96, 0, 76, 24, 47, 182, 68, 137, 149, 195, 67, 16, 187, 224, 74, 8, 82, 169, 87, 70, 44, 4, 192, 56, 13, 128, 44, 106, 146, 72, 194,
+                        245);
+            }
+        };
+
+        assertMatEqual(truth, descriptors);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(32, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_8U, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\ndescriptorSize: 64\n");
+
+        extractor.read(filename);
+
+        assertEquals(64, extractor.descriptorSize());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<descriptorSize>32</descriptorSize>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\ndescriptorSize: 32\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceDescriptorMatcherTest.java
new file mode 100644
index 0000000000..0f6b8f2efb
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceDescriptorMatcherTest.java
@@ -0,0 +1,270 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Core.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        List<KeyPoint> keypoints = Arrays.asList(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 0.643284f),
+                new DMatch(1, 1, 0, 0.92945856f),
+                new DMatch(2, 1, 0, 0.2841479f),
+                new DMatch(3, 1, 0, 0.9194034f),
+                new DMatch(4, 1, 0, 0.3006621f) };
+
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+
+        // OpenCVTestRunner.Log("matches found: " + matches.size());
+        // for (DMatch m : matches)
+        // OpenCVTestRunner.Log(m.toString());
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingDescriptorMatcherTest.java
new file mode 100644
index 0000000000..5a95d40f3e
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingDescriptorMatcherTest.java
@@ -0,0 +1,251 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BruteForceHammingDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(4, 4, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        return getTestDescriptors(getQueryImg());
+    }
+
+    private Mat getQueryImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, matSize - 40), new Point(matSize - 50, 50), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getTestDescriptors(Mat img) {
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainDescriptors() {
+        return getTestDescriptors(getTrainImg());
+    }
+
+    private Mat getTrainImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, 40), new Point(matSize - 40, matSize - 40), new Scalar(0), 8);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 51),
+                new DMatch(1, 2, 0, 42),
+                new DMatch(2, 1, 0, 40),
+                new DMatch(3, 3, 0, 53) };
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingLUTDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingLUTDescriptorMatcherTest.java
new file mode 100644
index 0000000000..c364cd6cfa
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingLUTDescriptorMatcherTest.java
@@ -0,0 +1,255 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BruteForceHammingLUTDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(4, 4, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        return getTestDescriptors(getQueryImg());
+    }
+
+    private Mat getQueryImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, matSize - 40), new Point(matSize - 50, 50), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getTestDescriptors(Mat img) {
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainDescriptors() {
+        return getTestDescriptors(getTrainImg());
+    }
+
+    private Mat getTrainImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, 40), new Point(matSize - 40, matSize - 40), new Scalar(0), 8);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMINGLUT);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 51),
+                new DMatch(1, 2, 0, 42),
+                new DMatch(2, 1, 0, 40),
+                new DMatch(3, 3, 0, 53) };
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        OpenCVTestRunner.Log("matches found: " + matches.size());
+        for (DMatch m : matches)
+            OpenCVTestRunner.Log(m.toString());
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceL1DescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceL1DescriptorMatcherTest.java
new file mode 100644
index 0000000000..4be17e8d9a
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceL1DescriptorMatcherTest.java
@@ -0,0 +1,265 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Core.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        List<KeyPoint> keypoints = Arrays.asList(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_L1);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 3.175296f),
+                new DMatch(1, 1, 0, 3.5954158f),
+                new DMatch(2, 1, 0, 1.2537984f),
+                new DMatch(3, 1, 0, 3.5761614f),
+                new DMatch(4, 1, 0, 1.3250958f) };
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceSL2DescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceSL2DescriptorMatcherTest.java
new file mode 100644
index 0000000000..42433d7413
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceSL2DescriptorMatcherTest.java
@@ -0,0 +1,274 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BruteForceSL2DescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+    
+    private float sqr(float val){
+        return val * val;
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Core.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        List<KeyPoint> keypoints = Arrays.asList(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_SL2);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, sqr(0.643284f)),
+                new DMatch(1, 1, 0, sqr(0.92945856f)),
+                new DMatch(2, 1, 0, sqr(0.2841479f)),
+                new DMatch(3, 1, 0, sqr(0.9194034f)),
+                new DMatch(4, 1, 0, sqr(0.3006621f)) };
+
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+
+        // OpenCVTestRunner.Log("matches found: " + matches.size());
+        // for (DMatch m : matches)
+        // OpenCVTestRunner.Log(m.toString());
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DENSEFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DENSEFeatureDetectorTest.java
new file mode 100644
index 0000000000..a5e7be57e5
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DENSEFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DENSEFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DMatchTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DMatchTest.java
new file mode 100644
index 0000000000..f5330c2d16
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DMatchTest.java
@@ -0,0 +1,44 @@
+package org.opencv.test.features2d;
+
+import org.opencv.features2d.DMatch;
+
+import junit.framework.TestCase;
+
+public class DMatchTest extends TestCase {
+    public void testDMatch() {
+        new DMatch();
+    }
+
+    public void testDMatchIntIntFloat() {
+        DMatch dm1 = new DMatch(1, 4, 4.0f);
+
+        assertEquals(1, dm1.queryIdx);
+        assertEquals(4, dm1.trainIdx);
+        assertEquals(4.0f, dm1.distance);
+    }
+
+    public void testDMatchIntIntIntFloat() {
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+
+        assertEquals(2, dm2.queryIdx);
+        assertEquals(6, dm2.trainIdx);
+        assertEquals(-1, dm2.imgIdx);
+        assertEquals(8.0f, dm2.distance);
+    }
+
+    public void testLessThan() {
+        DMatch dm1 = new DMatch(1, 4, 4.0f);
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+        assertTrue(dm1.lessThan(dm2));
+    }
+
+    public void testToString() {
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+
+        String actual = dm2.toString();
+
+        String expected = "DMatch [queryIdx=2, trainIdx=6, imgIdx=-1, distance=8.0]";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicDENSEFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicDENSEFeatureDetectorTest.java
new file mode 100644
index 0000000000..bd1a7a5811
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicDENSEFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicDENSEFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicFASTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicFASTFeatureDetectorTest.java
new file mode 100644
index 0000000000..770d4a55e9
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicFASTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicFASTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicGFTTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicGFTTFeatureDetectorTest.java
new file mode 100644
index 0000000000..83194bf039
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicGFTTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicGFTTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicHARRISFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicHARRISFeatureDetectorTest.java
new file mode 100644
index 0000000000..51fb0fb5cd
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicHARRISFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicHARRISFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicMSERFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicMSERFeatureDetectorTest.java
new file mode 100644
index 0000000000..202807c782
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicMSERFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicMSERFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicORBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicORBFeatureDetectorTest.java
new file mode 100644
index 0000000000..a0f1ab84d7
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicORBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicORBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIFTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIFTFeatureDetectorTest.java
new file mode 100644
index 0000000000..56f5a7cc04
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIFTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicSIFTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIMPLEBLOBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIMPLEBLOBFeatureDetectorTest.java
new file mode 100644
index 0000000000..942124ef28
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSIMPLEBLOBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicSIMPLEBLOBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicSTARFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSTARFeatureDetectorTest.java
new file mode 100644
index 0000000000..d4e687fe70
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSTARFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicSTARFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/DynamicSURFFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSURFFeatureDetectorTest.java
new file mode 100644
index 0000000000..34a767ca8b
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/DynamicSURFFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class DynamicSURFFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/FASTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/FASTFeatureDetectorTest.java
new file mode 100644
index 0000000000..13d13575b6
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/FASTFeatureDetectorTest.java
@@ -0,0 +1,144 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class FASTFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(100, 100, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, 100, 50, 100);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Mat img = new Mat(100, 100, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(30, 30), new Point(70, 70), new Scalar(0), 8);
+        return img;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        detector = FeatureDetector.create(FeatureDetector.FAST);
+
+        truth = new KeyPoint[] { new KeyPoint(32, 27, 6, -1, 254, 0, -1), new KeyPoint(27, 32, 6, -1, 254, 0, -1), new KeyPoint(73, 68, 6, -1, 254, 0, -1),
+                new KeyPoint(68, 73, 6, -1, 254, 0, -1) };
+
+        super.setUp();
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        Mat img = getTestImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(img, keypoints);
+
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints, EPS);
+
+        // OpenCVTestRunner.Log("points found: " + keypoints.size());
+        // for (KeyPoint kp : keypoints)
+        // OpenCVTestRunner.Log(kp.toString());
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(img, keypoints, mask);
+
+        assertListKeyPointEquals(Arrays.asList(truth[0], truth[1]), keypoints, EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename, "%YAML:1.0\nthreshold: 130\nnonmaxSuppression: 1\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints1 = new ArrayList<KeyPoint>();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename, "%YAML:1.0\nthreshold: 150\nnonmaxSuppression: 1\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints2 = new ArrayList<KeyPoint>();
+
+        detector.detect(grayChess, keypoints2);
+
+        assertTrue(keypoints2.size() <= keypoints1.size());
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename,
+                "<?xml version=\"1.0\"?>\n<opencv_storage>\n<threshold>130</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n</opencv_storage>\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints1 = new ArrayList<KeyPoint>();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename,
+                "<?xml version=\"1.0\"?>\n<opencv_storage>\n<threshold>150</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n</opencv_storage>\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints2 = new ArrayList<KeyPoint>();
+
+        detector.detect(grayChess, keypoints2);
+
+        assertTrue(keypoints2.size() <= keypoints1.size());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<threshold>10</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nthreshold: 10\nnonmaxSuppression: 1\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/Features2dTest.java b/modules/java/android_test/src/org/opencv/test/features2d/Features2dTest.java
new file mode 100644
index 0000000000..bdaf4efaa4
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/Features2dTest.java
@@ -0,0 +1,137 @@
+package org.opencv.test.features2d;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Range;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.Features2d;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.highgui.Highgui;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Features2dTest extends OpenCVTestCase {
+
+    public void testDrawKeypointsMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawKeypointsMatListOfKeyPointMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawKeypointsMatListOfKeyPointMatScalarInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalarListOfListOfByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalarListOfListOfByteInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalarListOfByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalarListOfByteInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testPTOD()
+    {
+        String detectorCfg = "%YAML:1.0\nhessianThreshold: 4000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n";
+        String extractorCfg = "%YAML:1.0\nnOctaves: 4\nnOctaveLayers: 2\nextended: 0\nupright: 0\n";
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+
+        String detectorCfgFile = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(detectorCfgFile, detectorCfg);
+        detector.read(detectorCfgFile);
+
+        String extractorCfgFile = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(extractorCfgFile, extractorCfg);
+        extractor.read(extractorCfgFile);
+
+        Mat imgTrain = Highgui.imread(OpenCVTestRunner.LENA_PATH, Highgui.CV_LOAD_IMAGE_GRAYSCALE);
+        Mat imgQuery = imgTrain.submat(new Range(0, imgTrain.rows() - 100), Range.all());
+
+        List<KeyPoint> trainKeypoints = new ArrayList<KeyPoint>();
+        List<KeyPoint> queryKeypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(imgTrain, trainKeypoints);
+        detector.detect(imgQuery, queryKeypoints);
+
+        // OpenCVTestRunner.Log("Keypoints found: " + trainKeypoints.size() +
+        // ":" + queryKeypoints.size());
+
+        Mat trainDescriptors = new Mat();
+        Mat queryDescriptors = new Mat();
+
+        extractor.compute(imgTrain, trainKeypoints, trainDescriptors);
+        extractor.compute(imgQuery, queryKeypoints, queryDescriptors);
+
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.add(Arrays.asList(trainDescriptors));
+        matcher.match(queryDescriptors, matches);
+
+        // OpenCVTestRunner.Log("Matches found: " + matches.size());
+
+        List<Point> points1 = new ArrayList<Point>();
+        List<Point> points2 = new ArrayList<Point>();
+
+        for (int i = 0; i < matches.size(); i++) {
+            DMatch match = matches.get(i);
+            points1.add(trainKeypoints.get(match.trainIdx).pt);
+            points2.add(queryKeypoints.get(match.queryIdx).pt);
+        }
+
+        Mat hmg = Calib3d.findHomography(points1, points2, Calib3d.RANSAC);
+
+        assertMatEqual(Mat.eye(3, 3, CvType.CV_64F), hmg, EPS);
+
+        Mat outimg = new Mat();
+        Features2d.drawMatches(imgQuery, queryKeypoints, imgTrain, trainKeypoints, matches, outimg);
+        String outputPath = OpenCVTestRunner.getOutputFileName("PTODresult.png");
+        Highgui.imwrite(outputPath, outimg);
+        // OpenCVTestRunner.Log("Output image is saved to: " + outputPath);
+    }
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/FernGenericDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/FernGenericDescriptorMatcherTest.java
new file mode 100644
index 0000000000..df4c69e25b
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/FernGenericDescriptorMatcherTest.java
@@ -0,0 +1,127 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class FernGenericDescriptorMatcherTest extends OpenCVTestCase {
+
+    public void testAdd() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPointMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCloneBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testClone() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainImages() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainKeypoints() {
+        fail("Not yet implemented");
+    }
+
+    public void testIsMaskSupported() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatchListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/FlannBasedDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/FlannBasedDescriptorMatcherTest.java
new file mode 100644
index 0000000000..21485b3f3d
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/FlannBasedDescriptorMatcherTest.java
@@ -0,0 +1,406 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class FlannBasedDescriptorMatcherTest extends OpenCVTestCase {
+
+    static final String xmlParamsDefault = "<?xml version=\"1.0\"?>\n"
+            + "<opencv_storage>\n"
+            + "<indexParams>\n"
+            + "  <_>\n"
+            + "    <name>algorithm</name>\n"
+            + "    <type>23</type>\n"
+            + "    <value>1</value></_>\n"
+            + "  <_>\n"
+            + "    <name>trees</name>\n"
+            + "    <type>4</type>\n"
+            + "    <value>4</value></_></indexParams>\n"
+            + "<searchParams>\n"
+            + "  <_>\n"
+            + "    <name>checks</name>\n"
+            + "    <type>4</type>\n"
+            + "    <value>32</value></_>\n"
+            + "  <_>\n"
+            + "    <name>eps</name>\n"
+            + "    <type>5</type>\n"
+            + "    <value>0.</value></_>\n"
+            + "  <_>\n"
+            + "    <name>sorted</name>\n"
+            + "    <type>15</type>\n"
+            + "    <value>1</value></_></searchParams>\n"
+            + "</opencv_storage>\n";
+    static final String ymlParamsDefault = "%YAML:1.0\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 23\n"
+            + "      value: 1\n"
+            + "   -\n"
+            + "      name: trees\n"
+            + "      type: 4\n"
+            + "      value: 4\n"
+            + "searchParams:\n"
+            + "   -\n"
+            + "      name: checks\n"
+            + "      type: 4\n"
+            + "      value: 32\n"
+            + "   -\n"
+            + "      name: eps\n"
+            + "      type: 5\n"
+            + "      value: 0.\n"
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 15\n"
+            + "      value: 1\n";
+    static final String ymlParamsModified = "%YAML:1.0\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 23\n"
+            + "      value: 6\n"// this line is changed!
+            + "   -\n"
+            + "      name: trees\n"
+            + "      type: 4\n"
+            + "      value: 4\n"
+            + "searchParams:\n"
+            + "   -\n"
+            + "      name: checks\n"
+            + "      type: 4\n"
+            + "      value: 32\n"
+            + "   -\n"
+            + "      name: eps\n"
+            + "      type: 5\n"
+            + "      value: 0.\n"
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 15\n"
+            + "      value: 1\n";
+
+    DescriptorMatcher matcher;
+
+    int matSize;
+
+    DMatch[] truth;
+
+    private Mat getBriefQueryDescriptors() {
+        return getBriefTestDescriptors(getBriefQueryImg());
+    }
+
+    private Mat getBriefQueryImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, matSize - 40), new Point(matSize - 50, 50), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getBriefTestDescriptors(Mat img) {
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getBriefTrainDescriptors() {
+        return getBriefTestDescriptors(getBriefTrainImg());
+    }
+
+    private Mat getBriefTrainImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(img, new Point(40, 40), new Point(matSize - 40, matSize - 40), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Core.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        List<KeyPoint> keypoints = Arrays.asList(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 0.643284f),
+                new DMatch(1, 1, 0, 0.92945856f),
+                new DMatch(2, 1, 0, 0.2841479f),
+                new DMatch(3, 1, 0, 0.9194034f),
+                new DMatch(4, 1, 0, 0.3006621f) };
+
+        super.setUp();
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        matcher.add(Arrays.asList(train));
+
+        try {
+            matcher.clone();
+            fail("Expected CvException (CV_StsNotImplemented)");
+        } catch (CvException cverr) {
+            // expected
+        }
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertFalse(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+
+        // OpenCVTestRunner.Log("matches found: " + matches.size());
+        // for (DMatch m : matches)
+        // OpenCVTestRunner.Log(m.toString());
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches, EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, ymlParamsModified);
+
+        matcher.read(filename);
+
+        Mat train = getBriefTrainDescriptors();
+        Mat query = getBriefQueryDescriptors();
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(new DMatch(0, 0, 0, 0),
+                new DMatch(1, 2, 0, 0),
+                new DMatch(2, 1, 0, 0),
+                new DMatch(3, 3, 0, 0)), matches, EPS);
+    }
+
+    public void testTrain() {
+        Mat train = getTrainDescriptors();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+    }
+
+    public void testTrainNoData() {
+        try {
+            matcher.train();
+            fail("Expected CvException - FlannBasedMatcher::train should fail on empty train set");
+        } catch (CvException cverr) {
+            // expected
+        }
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        matcher.write(filename);
+
+        assertEquals(xmlParamsDefault, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        assertEquals(ymlParamsDefault, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GFTTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GFTTFeatureDetectorTest.java
new file mode 100644
index 0000000000..09661c67f6
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GFTTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GFTTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridDENSEFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridDENSEFeatureDetectorTest.java
new file mode 100644
index 0000000000..056d893c2b
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridDENSEFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridDENSEFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridFASTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridFASTFeatureDetectorTest.java
new file mode 100644
index 0000000000..c4c6959703
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridFASTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridFASTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridGFTTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridGFTTFeatureDetectorTest.java
new file mode 100644
index 0000000000..9181f97bee
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridGFTTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridGFTTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridHARRISFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridHARRISFeatureDetectorTest.java
new file mode 100644
index 0000000000..86c7677775
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridHARRISFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridHARRISFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridMSERFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridMSERFeatureDetectorTest.java
new file mode 100644
index 0000000000..c761049dea
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridMSERFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridMSERFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridORBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridORBFeatureDetectorTest.java
new file mode 100644
index 0000000000..c987333a3f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridORBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridORBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridSIFTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridSIFTFeatureDetectorTest.java
new file mode 100644
index 0000000000..46d2a08734
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridSIFTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridSIFTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridSIMPLEBLOBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridSIMPLEBLOBFeatureDetectorTest.java
new file mode 100644
index 0000000000..62a5dd3ec4
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridSIMPLEBLOBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridSIMPLEBLOBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridSTARFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridSTARFeatureDetectorTest.java
new file mode 100644
index 0000000000..d78dc242f0
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridSTARFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridSTARFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/GridSURFFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/GridSURFFeatureDetectorTest.java
new file mode 100644
index 0000000000..012d825274
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/GridSURFFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class GridSURFFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/HARRISFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/HARRISFeatureDetectorTest.java
new file mode 100644
index 0000000000..5e7fd7d3ce
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/HARRISFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class HARRISFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/KeyPointTest.java b/modules/java/android_test/src/org/opencv/test/features2d/KeyPointTest.java
new file mode 100644
index 0000000000..2a0b9253ef
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/KeyPointTest.java
@@ -0,0 +1,71 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Point;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+
+public class KeyPointTest extends OpenCVTestCase {
+
+    private float angle;
+    private int classId;
+    private KeyPoint keyPoint;
+    private int octave;
+    private float response;
+    private float size;
+    private float x;
+    private float y;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        keyPoint = null;
+        x = 1.0f;
+        y = 2.0f;
+        size = 3.0f;
+        angle = 30.0f;
+        response = 2.0f;
+        octave = 1;
+        classId = 1;
+    }
+
+    public void testKeyPoint() {
+        keyPoint = new KeyPoint();
+        assertPointEquals(new Point(0, 0), keyPoint.pt, EPS);
+    }
+
+    public void testKeyPointFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size);
+        assertPointEquals(new Point(1, 2), keyPoint.pt, EPS);
+    }
+
+    public void testKeyPointFloatFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size, 10.0f);
+        assertEquals(10.0f, keyPoint.angle);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f);
+        assertEquals(1.0f, keyPoint.response);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloatInt() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1);
+        assertEquals(1, keyPoint.octave);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloatIntInt() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1, 1);
+        assertEquals(1, keyPoint.class_id);
+    }
+
+    public void testToString() {
+        keyPoint = new KeyPoint(x, y, size, angle, response, octave, classId);
+
+        String actual = keyPoint.toString();
+
+        String expected = "KeyPoint [pt={1.0, 2.0}, size=3.0, angle=30.0, response=2.0, octave=1, class_id=1]";
+        assertEquals(expected, actual);
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/MSERFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/MSERFeatureDetectorTest.java
new file mode 100644
index 0000000000..98ae4d7025
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/MSERFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class MSERFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/ORBDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/ORBDescriptorExtractorTest.java
new file mode 100644
index 0000000000..0e46a0dbd3
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/ORBDescriptorExtractorTest.java
@@ -0,0 +1,113 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ORBDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        extractor = DescriptorExtractor.create(DescriptorExtractor.ORB);
+        matSize = 100;
+
+        super.setUp();
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        List<KeyPoint> keypoints = Arrays.asList(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0, 20, 51, 88, 22, 14, 181, 78, 111, 36, 144, 62, 0, 188, 196, 4, 8, 133, 80, 96, 18, 64, 29, 0,
+                        254, 230, 247, 12, 2, 78, 129, 70, 145);
+            }
+        };
+        assertMatEqual(truth, descriptors);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(32, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_8U, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        List<KeyPoint> keypoints = Arrays.asList(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nscaleFactor: 1.1\nnLevels: 3\nfirstLevel: 0\nedgeThreshold: 31\npatchSize: 31\n");
+        extractor.read(filename);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0, 20, 55, 88, 20, 14, 49, 70, 111, 148, 144, 30, 16, 252, 133, 0, 8, 5, 85, 32, 0, 74, 25, 0,
+                        252, 119, 191, 4, 2, 66, 1, 66, 145);
+            }
+        };
+        assertMatEqual(truth, descriptors);
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<scaleFactor>1.2000000476837158e+00</scaleFactor>\n<nLevels>3</nLevels>\n<firstLevel>0</firstLevel>\n<edgeThreshold>31</edgeThreshold>\n<patchSize>31</patchSize>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nscaleFactor: 1.2000000476837158e+00\nnLevels: 3\nfirstLevel: 0\nedgeThreshold: 31\npatchSize: 31\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/ORBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/ORBFeatureDetectorTest.java
new file mode 100644
index 0000000000..b4c23d8f62
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/ORBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class ORBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/OneWayGenericDescriptorMatcherTest.java b/modules/java/android_test/src/org/opencv/test/features2d/OneWayGenericDescriptorMatcherTest.java
new file mode 100644
index 0000000000..f96460478f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/OneWayGenericDescriptorMatcherTest.java
@@ -0,0 +1,127 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OneWayGenericDescriptorMatcherTest extends OpenCVTestCase {
+
+    public void testAdd() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPointMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCloneBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testClone() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainImages() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainKeypoints() {
+        fail("Not yet implemented");
+    }
+
+    public void testIsMaskSupported() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatchListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/OpponentBRIEFDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/OpponentBRIEFDescriptorExtractorTest.java
new file mode 100644
index 0000000000..b158124ec1
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/OpponentBRIEFDescriptorExtractorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class OpponentBRIEFDescriptorExtractorTest extends TestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/OpponentORBDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/OpponentORBDescriptorExtractorTest.java
new file mode 100644
index 0000000000..1ee5432092
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/OpponentORBDescriptorExtractorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class OpponentORBDescriptorExtractorTest extends TestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/OpponentSIFTDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/OpponentSIFTDescriptorExtractorTest.java
new file mode 100644
index 0000000000..de20c14094
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/OpponentSIFTDescriptorExtractorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class OpponentSIFTDescriptorExtractorTest extends TestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/OpponentSURFDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/OpponentSURFDescriptorExtractorTest.java
new file mode 100644
index 0000000000..e4271289b1
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/OpponentSURFDescriptorExtractorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class OpponentSURFDescriptorExtractorTest extends TestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidDENSEFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidDENSEFeatureDetectorTest.java
new file mode 100644
index 0000000000..cadabed2a7
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidDENSEFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidDENSEFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidFASTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidFASTFeatureDetectorTest.java
new file mode 100644
index 0000000000..5527940ccc
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidFASTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidFASTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidGFTTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidGFTTFeatureDetectorTest.java
new file mode 100644
index 0000000000..13c45f1c94
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidGFTTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidGFTTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidHARRISFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidHARRISFeatureDetectorTest.java
new file mode 100644
index 0000000000..94ef84170b
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidHARRISFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidHARRISFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidMSERFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidMSERFeatureDetectorTest.java
new file mode 100644
index 0000000000..c8891f7267
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidMSERFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidMSERFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidORBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidORBFeatureDetectorTest.java
new file mode 100644
index 0000000000..a507e5122c
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidORBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidORBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIFTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIFTFeatureDetectorTest.java
new file mode 100644
index 0000000000..27aa5f666d
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIFTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidSIFTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIMPLEBLOBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIMPLEBLOBFeatureDetectorTest.java
new file mode 100644
index 0000000000..9f640f0ecd
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSIMPLEBLOBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidSIMPLEBLOBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidSTARFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSTARFeatureDetectorTest.java
new file mode 100644
index 0000000000..ea826362e9
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSTARFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidSTARFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/PyramidSURFFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSURFFeatureDetectorTest.java
new file mode 100644
index 0000000000..d212d0e2d8
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/PyramidSURFFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class PyramidSURFFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/SIFTDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/SIFTDescriptorExtractorTest.java
new file mode 100644
index 0000000000..b9d720cb6e
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/SIFTDescriptorExtractorTest.java
@@ -0,0 +1,111 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class SIFTDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    KeyPoint keypoint;
+    int matSize;
+    Mat truth;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        extractor = DescriptorExtractor.create(DescriptorExtractor.SIFT);
+        keypoint = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        matSize = 100;
+        truth = new Mat(1, 128, CvType.CV_32FC1) {
+            {
+                put(0, 0, 123, 0, 0, 1, 123, 0, 0, 1, 123, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 123, 0, 0, 2, 123, 0, 0, 2, 123, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 123, 30,
+                        7, 31, 123, 0, 0, 0, 123, 52, 88, 0, 0, 0, 0, 0, 0, 2, 123, 0, 0, 0, 0, 0, 0, 1, 110, 0, 0, 0, 0, 0, 18, 37, 18, 34, 16,
+                        21, 12, 23, 12, 50, 123, 0, 0, 0, 90, 26, 0, 3, 123, 0, 0, 1, 122, 0, 0, 2, 123, 0, 0, 1, 93, 0);
+            }
+        };
+
+        super.setUp();
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        List<KeyPoint> keypoints = Arrays.asList(keypoint);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        assertMatEqual(truth, descriptors, EPS);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_32F, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        List<KeyPoint> keypoints = Arrays.asList(keypoint);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename,
+                "%YAML:1.0\nmagnification: 3.\nisNormalize: 1\nrecalculateAngles: 1\nnOctaves: 6\nnOctaveLayers: 4\nfirstOctave: -1\nangleMode: 0\n");
+
+        extractor.read(filename);
+
+        extractor.compute(img, keypoints, descriptors);
+        assertMatNotEqual(truth, descriptors, EPS);
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<magnification>3.</magnification>\n<isNormalize>1</isNormalize>\n<recalculateAngles>1</recalculateAngles>\n<nOctaves>4</nOctaves>\n<nOctaveLayers>3</nOctaveLayers>\n<firstOctave>-1</firstOctave>\n<angleMode>0</angleMode>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nmagnification: 3.\nisNormalize: 1\nrecalculateAngles: 1\nnOctaves: 4\nnOctaveLayers: 3\nfirstOctave: -1\nangleMode: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/SIFTFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/SIFTFeatureDetectorTest.java
new file mode 100644
index 0000000000..dc381ca8db
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/SIFTFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class SIFTFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/SIMPLEBLOBFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/SIMPLEBLOBFeatureDetectorTest.java
new file mode 100644
index 0000000000..c27f8c3e18
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/SIMPLEBLOBFeatureDetectorTest.java
@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import junit.framework.TestCase;
+
+public class SIMPLEBLOBFeatureDetectorTest extends TestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/STARFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/STARFeatureDetectorTest.java
new file mode 100644
index 0000000000..768bd89d33
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/STARFeatureDetectorTest.java
@@ -0,0 +1,133 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class STARFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Scalar color = new Scalar(0);
+        int center = matSize / 2;
+        int radius = 6;
+        int offset = 40;
+
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.circle(img, new Point(center - offset, center), radius, color, -1);
+        Core.circle(img, new Point(center + offset, center), radius, color, -1);
+        Core.circle(img, new Point(center, center - offset), radius, color, -1);
+        Core.circle(img, new Point(center, center + offset), radius, color, -1);
+        Core.circle(img, new Point(center, center), radius, color, -1);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        detector = FeatureDetector.create(FeatureDetector.STAR);
+
+        matSize = 200;
+
+        truth = new KeyPoint[] {
+                new KeyPoint(95, 80, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(105, 80, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(80, 95, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(120, 95, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(100, 100, 8, -1, -219.90825f, 0, -1),
+                new KeyPoint(80, 105, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(120, 105, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(95, 120, 22, -1, 31.595734f, 0, -1),
+                new KeyPoint(105, 120, 22, -1, 31.595734f, 0, -1) };
+
+        super.setUp();
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        Mat img = getTestImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(img, keypoints);
+
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints, EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(img, keypoints, mask);
+
+        assertListKeyPointEquals(Arrays.asList(truth[0], truth[2], truth[5], truth[7]), keypoints, EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        Mat img = getTestImg();
+
+        List<KeyPoint> keypoints1 = new ArrayList<KeyPoint>();
+        detector.detect(img, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nmaxSize: 45\nresponseThreshold: 150\nlineThresholdProjected: 10\nlineThresholdBinarized: 8\nsuppressNonmaxSize: 5\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints2 = new ArrayList<KeyPoint>();
+        detector.detect(img, keypoints2);
+
+        assertTrue(keypoints2.size() <= keypoints1.size());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<maxSize>45</maxSize>\n<responseThreshold>30</responseThreshold>\n<lineThresholdProjected>10</lineThresholdProjected>\n<lineThresholdBinarized>8</lineThresholdBinarized>\n<suppressNonmaxSize>5</suppressNonmaxSize>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nmaxSize: 45\nresponseThreshold: 30\nlineThresholdProjected: 10\nlineThresholdBinarized: 8\nsuppressNonmaxSize: 5\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/SURFDescriptorExtractorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/SURFDescriptorExtractorTest.java
new file mode 100644
index 0000000000..f057ef02b0
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/SURFDescriptorExtractorTest.java
@@ -0,0 +1,105 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class SURFDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+        matSize = 100;
+
+        super.setUp();
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        List<KeyPoint> keypoints = Arrays.asList(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 64, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0, 0, 0, 0, 0.011540107, 0.0029440077, 0.095483348, 0.018144149, 0.00014820647, 0, 0.00014820647, 0, 0, 0, 0, 0, 0, -0.00014820647,
+                        0, 0.00014820647, 0.10196275, 0.0099145742, 0.57075155, 0.047922116, 0, 0, 0, 0, 0, 0, 0, 0, 0.0029440068, -0.011540107, 0.018144149,
+                        0.095483348, 0.085385554, -0.054076977, 0.34105155, 0.47911066, 0.023395451, -0.11012388, 0.088196531, 0.50863767, 0.0031790689,
+                        -0.019882837, 0.0089476965, 0.054817006, -0.0033560959, -0.0011770058, 0.0033560959, 0.0011770058, 0.019882834, 0.0031790687,
+                        0.054817006, 0.0089476984, 0, 0, 0, 0, -0.0011770058, 0.0033560959, 0.0011770058, 0.0033560959);
+            }
+        };
+
+        assertMatEqual(truth, descriptors, EPS);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(64, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_32F, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nnOctaves: 4\nnOctaveLayers: 2\nextended: 1\nupright: 0\n");
+
+        extractor.read(filename);
+
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<nOctaves>4</nOctaves>\n<nOctaveLayers>2</nOctaveLayers>\n<extended>0</extended>\n<upright>0</upright>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nnOctaves: 4\nnOctaveLayers: 2\nextended: 0\nupright: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/features2d/SURFFeatureDetectorTest.java b/modules/java/android_test/src/org/opencv/test/features2d/SURFFeatureDetectorTest.java
new file mode 100644
index 0000000000..03bcd8b05d
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/features2d/SURFFeatureDetectorTest.java
@@ -0,0 +1,163 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class SURFFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    private void order(List<KeyPoint> points) {
+        Collections.sort(points, new Comparator<KeyPoint>() {
+            public int compare(KeyPoint p1, KeyPoint p2) {
+                if (p1.angle < p2.angle)
+                    return -1;
+                if (p1.angle > p2.angle)
+                    return 1;
+                return 0;
+            }
+        });
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        detector = FeatureDetector.create(FeatureDetector.SURF);
+
+        matSize = 100;
+
+        truth = new KeyPoint[] { new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1),
+                new KeyPoint(44.224422454833984f, 44.224422454833984f, 16, 99.75463f, 8617.863f, 1, -1),
+                new KeyPoint(44.224422454833984f, 55.775577545166016f, 16, 189.7546f, 8617.863f, 1, -1),
+                new KeyPoint(55.775577545166016f, 55.775577545166016f, 16, 279.75464f, 8617.863f, 1, -1) };
+
+        super.setUp();
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        List<List<KeyPoint>> keypoints = new ArrayList<List<KeyPoint>>();
+        Mat cross = getTestImg();
+        List<Mat> crosses = new ArrayList<Mat>(3);
+        crosses.add(cross);
+        crosses.add(cross);
+        crosses.add(cross);
+
+        detector.detect(crosses, keypoints);
+
+        assertEquals(3, keypoints.size());
+
+        for (List<KeyPoint> lkp : keypoints) {
+            order(lkp);
+            assertListKeyPointEquals(Arrays.asList(truth), lkp, EPS);
+        }
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+        Mat cross = getTestImg();
+
+        detector.detect(cross, keypoints);
+
+        order(keypoints);
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints, EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        List<KeyPoint> keypoints = new ArrayList<KeyPoint>();
+
+        detector.detect(img, keypoints, mask);
+
+        order(keypoints);
+        assertListKeyPointEquals(Arrays.asList(truth[1], truth[2]), keypoints, EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        Mat cross = getTestImg();
+
+        List<KeyPoint> keypoints1 = new ArrayList<KeyPoint>();
+        detector.detect(cross, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        List<KeyPoint> keypoints2 = new ArrayList<KeyPoint>();
+        detector.detect(cross, keypoints2);
+
+        assertTrue(keypoints2.size() <= keypoints1.size());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<hessianThreshold>400.</hessianThreshold>\n<octaves>3</octaves>\n<octaveLayers>4</octaveLayers>\n<upright>0</upright>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nhessianThreshold: 400.\noctaves: 3\noctaveLayers: 4\nupright: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/highgui/HighguiTest.java b/modules/java/android_test/src/org/opencv/test/highgui/HighguiTest.java
new file mode 100644
index 0000000000..8e0a08cc6f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/highgui/HighguiTest.java
@@ -0,0 +1,45 @@
+package org.opencv.test.highgui;
+
+import org.opencv.highgui.Highgui;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class HighguiTest extends OpenCVTestCase {
+
+    public void testImdecode() {
+        fail("Not yet implemented");
+    }
+
+    public void testImencodeStringMatListOfByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testImencodeStringMatListOfByteListOfInteger() {
+        fail("Not yet implemented");
+    }
+
+    public void testImreadString() {
+        dst = Highgui.imread(OpenCVTestRunner.LENA_PATH);
+        assertTrue(!dst.empty());
+        assertEquals(3, dst.channels());
+        assertTrue(512 == dst.cols());
+        assertTrue(512 == dst.rows());
+    }
+
+    public void testImreadStringInt() {
+        dst = Highgui.imread(OpenCVTestRunner.LENA_PATH, 0);
+        assertTrue(!dst.empty());
+        assertEquals(1, dst.channels());
+        assertTrue(512 == dst.cols());
+        assertTrue(512 == dst.rows());
+    }
+
+    public void testImwriteStringMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testImwriteStringMatListOfInteger() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/highgui/VideoCaptureTest.java b/modules/java/android_test/src/org/opencv/test/highgui/VideoCaptureTest.java
new file mode 100644
index 0000000000..c6901c5e4d
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/highgui/VideoCaptureTest.java
@@ -0,0 +1,177 @@
+package org.opencv.test.highgui;
+
+import java.util.List;
+
+import org.opencv.core.Size;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class VideoCaptureTest extends OpenCVTestCase {
+
+    private VideoCapture capture;
+    private boolean isOpened;
+    private boolean isSucceed;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        capture = null;
+        isSucceed = false;
+        isOpened = false;
+    }
+
+    public void testGet() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            double frameWidth = capture.get(Highgui.CV_CAP_PROP_FRAME_WIDTH);
+            assertTrue(0 != frameWidth);
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testGetSupportedPreviewSizes() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            List<Size> sizes = capture.getSupportedPreviewSizes();
+            assertNotNull(sizes);
+            assertFalse(sizes.isEmpty());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testGrab() {
+        capture = new VideoCapture();
+        isSucceed = capture.grab();
+        assertFalse(isSucceed);
+    }
+
+    public void testGrabFromRealCamera() {
+        try {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            isSucceed = capture.grab();
+            assertTrue(isSucceed);
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testIsOpened() {
+        capture = new VideoCapture();
+        assertFalse(capture.isOpened());
+    }
+
+    public void testIsOpenedRealCamera() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            isOpened = capture.isOpened();
+            assertTrue(isOpened);
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testOpen() {
+        try
+        {
+            capture = new VideoCapture();
+            capture.open(Highgui.CV_CAP_ANDROID);
+            isOpened = capture.isOpened();
+            assertTrue(isOpened);
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testRead() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            isSucceed = capture.read(dst);
+            assertTrue(isSucceed);
+            assertFalse(dst.empty());
+            assertEquals(3, dst.channels());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testRelease() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            capture.release();
+            assertFalse(capture.isOpened());
+            capture = null;
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testRetrieveMat() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            capture.grab();
+            isSucceed = capture.retrieve(dst);
+            assertTrue(isSucceed);
+            assertFalse(dst.empty());
+            assertEquals(3, dst.channels());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testRetrieveMatInt() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            capture.grab();
+            isSucceed = capture.retrieve(dst, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+            assertTrue(isSucceed);
+            assertFalse(dst.empty());
+            assertEquals(1, dst.channels());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testSet() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            capture.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, 640);
+            capture.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, 480);
+            double frameWidth = capture.get(Highgui.CV_CAP_PROP_FRAME_WIDTH);
+            capture.read(dst);
+            assertEquals(640.0, frameWidth);
+            assertEquals(640, dst.cols());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+
+    public void testVideoCapture() {
+        capture = new VideoCapture();
+        assertNotNull(capture);
+        assertFalse(capture.isOpened());
+    }
+
+    public void testVideoCaptureInt() {
+        try
+        {
+            capture = new VideoCapture(Highgui.CV_CAP_ANDROID);
+            assertNotNull(capture);
+            assertTrue(capture.isOpened());
+        } finally {
+            if (capture != null) capture.release();
+        }
+    }
+}
diff --git a/modules/java/android_test/src/org/opencv/test/imgproc/ImgprocTest.java b/modules/java/android_test/src/org/opencv/test/imgproc/ImgprocTest.java
new file mode 100644
index 0000000000..0409056b4f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/imgproc/ImgprocTest.java
@@ -0,0 +1,2188 @@
+package org.opencv.test.imgproc;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.RotatedRect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.core.TermCriteria;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.test.OpenCVTestCase;
+
+public class ImgprocTest extends OpenCVTestCase {
+
+    Point anchorPoint;
+    private int imgprocSz;
+    Size size;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        imgprocSz = 2;
+        anchorPoint = new Point(2, 2);
+        size = new Size(3, 3);
+    }
+
+    public void testAccumulateMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulate(src, dst);
+        Imgproc.accumulate(src, dst2);
+
+        assertMatEqual(src, dst, EPS);
+        assertMatEqual(getMat(CvType.CV_64F, 4), dst2, EPS);
+    }
+
+    public void testAccumulateMatMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulate(src, dst, mask);
+        Imgproc.accumulate(src, dst2, mask);
+
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 2)), dst, EPS);
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4), 2), dst2, EPS);
+    }
+
+    public void testAccumulateProductMatMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateProduct(src, src, dst);
+        Imgproc.accumulateProduct(src, dst, dst2);
+
+        assertMatEqual(getMat(CvType.CV_64F, 4), dst, EPS);
+        assertMatEqual(getMat(CvType.CV_64F, 10), dst2, EPS);
+    }
+
+    public void testAccumulateProductMatMatMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateProduct(src, src, dst, mask);
+        Imgproc.accumulateProduct(src, dst, dst2, mask);
+
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4)), dst, EPS);
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 10), 2), dst2, EPS);
+    }
+
+    public void testAccumulateSquareMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateSquare(src, dst);
+        Imgproc.accumulateSquare(src, dst2);
+
+        assertMatEqual(getMat(CvType.CV_64F, 4), dst, EPS);
+        assertMatEqual(getMat(CvType.CV_64F, 6), dst2, EPS);
+    }
+
+    public void testAccumulateSquareMatMatMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
+        Mat dst = getMat(CvType.CV_64F, 0);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateSquare(src, dst, mask);
+        Imgproc.accumulateSquare(src, dst2, mask);
+
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4)), dst, EPS);
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 6), 2), dst2, EPS);
+    }
+
+    public void testAccumulateWeightedMatMatDouble() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat dst = getMat(CvType.CV_64F, 4);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateWeighted(src, dst, 0.5);
+        Imgproc.accumulateWeighted(src, dst2, 2);
+
+        assertMatEqual(getMat(CvType.CV_64F, 3), dst, EPS);
+        assertMatEqual(getMat(CvType.CV_64F, 2), dst2, EPS);
+    }
+
+    public void testAccumulateWeightedMatMatDoubleMat() {
+        Mat src = getMat(CvType.CV_64F, 2);
+        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
+        Mat dst = getMat(CvType.CV_64F, 4);
+        Mat dst2 = src.clone();
+
+        Imgproc.accumulateWeighted(src, dst, 0.5, mask);
+        Imgproc.accumulateWeighted(src, dst2, 2, mask);
+
+        assertMatEqual(makeMask(getMat(CvType.CV_64F, 3), 4), dst, EPS);
+        assertMatEqual(getMat(CvType.CV_64F, 2), dst2, EPS);
+    }
+
+    public void testAdaptiveThreshold() {
+        Mat src = makeMask(getMat(CvType.CV_8U, 50), 20);
+        Mat dst = new Mat();
+
+        Imgproc.adaptiveThreshold(src, dst, 1, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, 0);
+
+        assertEquals(src.rows(), Core.countNonZero(dst));
+    }
+
+    public void testApproxPolyDP() {
+        Mat curve = new Mat(1, 5, CvType.CV_32FC2);
+        curve.put(0, 0, 1, 3, 2, 4, 3, 5, 4, 4, 5, 3);
+
+        Imgproc.approxPolyDP(curve, dst, EPS, true);
+
+        Mat approxCurve = new Mat(3, 1, CvType.CV_32FC2) {
+            {
+                put(0, 0, 1, 3, 3, 5, 5, 3);
+            }
+        };
+        assertMatEqual(approxCurve, dst, EPS);
+    }
+
+    public void testArcLength() {
+        List<Point> curve = Arrays.asList(new Point(1, 3), new Point(2, 4), new Point(3, 5), new Point(4, 4), new Point(5, 3));
+
+        double arcLength = Imgproc.arcLength(curve, false);
+
+        assertEquals(5.656854152679443, arcLength);
+    }
+
+    public void testBilateralFilterMatMatIntDoubleDouble() {
+        Imgproc.bilateralFilter(gray255, dst, 5, 10, 5);
+
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testBilateralFilterMatMatIntDoubleDoubleInt() {
+        Imgproc.bilateralFilter(gray255, dst, 5, 10, 5, Imgproc.BORDER_REFLECT);
+
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testBlurMatMatSize() {
+        Imgproc.blur(gray0, dst, size);
+        assertMatEqual(gray0, dst);
+
+        Imgproc.blur(gray255, dst, size);
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testBlurMatMatSizePoint() {
+        Imgproc.blur(gray0, dst, size, anchorPoint);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testBlurMatMatSizePointInt() {
+        Imgproc.blur(gray0, dst, size, anchorPoint, Imgproc.BORDER_REFLECT);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testBorderInterpolate() {
+        float val1 = Imgproc.borderInterpolate(100, 150, Imgproc.BORDER_REFLECT_101);
+        assertEquals(100f, val1);
+
+        float val2 = Imgproc.borderInterpolate(-5, 10, Imgproc.BORDER_WRAP);
+        assertEquals(5f, val2);
+    }
+
+    public void testBoundingRect() {
+        List<Point> points = Arrays.asList(new Point(0, 0), new Point(0, 4), new Point(4, 0), new Point(4, 4));
+        Point p1 = new Point(1, 1);
+        Point p2 = new Point(-5, -2);
+
+        Rect bbox = Imgproc.boundingRect(points);
+
+        assertTrue(bbox.contains(p1));
+        assertFalse(bbox.contains(p2));
+    }
+
+    public void testBoxFilterMatMatIntSize() {
+        Size size = new Size(3, 3);
+        Imgproc.boxFilter(gray0, dst, 8, size);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testBoxFilterMatMatIntSizePoint() {
+        Imgproc.boxFilter(gray0, dst, 8, size, anchorPoint);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testBoxFilterMatMatIntSizePointBoolean() {
+        Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false);
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testBoxFilterMatMatIntSizePointBooleanInt() {
+        Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false, Imgproc.BORDER_REFLECT);
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testCalcBackProject() {
+        List<Mat> images = Arrays.asList(grayChess);
+        List<Integer> channels = Arrays.asList(0);
+        List<Integer> histSize = Arrays.asList(10);
+        List<Float> ranges = Arrays.asList(0f, 256f);
+
+        Mat hist = new Mat();
+        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
+        Core.normalize(hist, hist);
+
+        Imgproc.calcBackProject(images, channels, hist, dst, ranges, 255);
+
+        assertEquals(grayChess.size(), dst.size());
+        assertEquals(grayChess.depth(), dst.depth());
+        assertFalse(0 == Core.countNonZero(dst));
+    }
+
+    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() {
+        List<Mat> images = Arrays.asList(gray128);
+        List<Integer> channels = Arrays.asList(0);
+        List<Integer> histSize = Arrays.asList(10);
+        List<Float> ranges = Arrays.asList(0f, 256f);
+        Mat hist = new Mat();
+
+        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
+
+        truth = new Mat(10, 1, CvType.CV_32F, Scalar.all(0)) {
+            {
+                put(5, 0, 100);
+            }
+        };
+        assertMatEqual(truth, hist, EPS);
+    }
+
+    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2d() {
+        List<Mat> images = Arrays.asList(gray255, gray128);
+        List<Integer> channels = Arrays.asList(0, 1);
+        List<Integer> histSize = Arrays.asList(10, 10);
+        List<Float> ranges = Arrays.asList(0f, 256f, 0f, 256f);
+        Mat hist = new Mat();
+
+        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
+
+        truth = new Mat(10, 10, CvType.CV_32F, Scalar.all(0)) {
+            {
+                put(9, 5, 100);
+            }
+        };
+        assertMatEqual(truth, hist, EPS);
+    }
+
+    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
+        List<Mat> images = Arrays.asList(gray255, gray128);
+        List<Integer> channels = Arrays.asList(0, 1);
+        List<Integer> histSize = Arrays.asList(10, 10);
+        List<Float> ranges = Arrays.asList(0f, 256f, 0f, 256f);
+        Mat hist = new Mat();
+
+        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, true);
+
+        truth = new Mat(10, 10, CvType.CV_32F, Scalar.all(0)) {
+            {
+                put(9, 5, 100);
+            }
+        };
+        assertMatEqual(truth, hist, EPS);
+    }
+
+    public void testCannyMatMatDoubleDouble() {
+        Imgproc.Canny(gray255, dst, 5, 10);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testCannyMatMatDoubleDoubleInt() {
+        Imgproc.Canny(gray255, dst, 5, 10, 5);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testCannyMatMatDoubleDoubleIntBoolean() {
+        Imgproc.Canny(gray0, dst, 5, 10, 5, true);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testCompareHist() {
+        Mat H1 = new Mat(3, 1, CvType.CV_32F);
+        Mat H2 = new Mat(3, 1, CvType.CV_32F);
+        H1.put(0, 0, 1, 2, 3);
+        H2.put(0, 0, 4, 5, 6);
+
+        double distance = Imgproc.compareHist(H1, H2, Imgproc.CV_COMP_CORREL);
+
+        assertEquals(1., distance);
+    }
+
+    public void testContourAreaMat() {
+        Mat contour = new Mat(1, 4, CvType.CV_32FC2);
+        contour.put(0, 0, 0, 0, 10, 0, 10, 10, 5, 4);
+
+        double area = Imgproc.contourArea(contour);
+
+        assertEquals(45., area);
+    }
+
+    public void testContourAreaMatBoolean() {
+        Mat contour = new Mat(1, 4, CvType.CV_32FC2);
+        contour.put(0, 0, 0, 0, 10, 0, 10, 10, 5, 4);
+
+        double area = Imgproc.contourArea(contour, true);
+
+        assertEquals(45., area);
+        // TODO_: write better test
+    }
+
+    public void testConvertMapsMatMatMatMatInt() {
+        Mat map1 = new Mat(1, 4, CvType.CV_32FC1, new Scalar(1));
+        Mat map2 = new Mat(1, 4, CvType.CV_32FC1, new Scalar(2));
+        Mat dstmap1 = new Mat(1, 4, CvType.CV_16SC2);
+        Mat dstmap2 = new Mat(1, 4, CvType.CV_16UC1);
+
+        Imgproc.convertMaps(map1, map2, dstmap1, dstmap2, CvType.CV_16SC2);
+
+        Mat truthMap1 = new Mat(1, 4, CvType.CV_16SC2);
+        truthMap1.put(0, 0, 1, 2, 1, 2, 1, 2, 1, 2);
+        assertMatEqual(truthMap1, dstmap1);
+        Mat truthMap2 = new Mat(1, 4, CvType.CV_16UC1, new Scalar(0));
+        assertMatEqual(truthMap2, dstmap2);
+    }
+
+    public void testConvertMapsMatMatMatMatIntBoolean() {
+        Mat map1 = new Mat(1, 3, CvType.CV_32FC1, new Scalar(2));
+        Mat map2 = new Mat(1, 3, CvType.CV_32FC1, new Scalar(4));
+        Mat dstmap1 = new Mat(1, 3, CvType.CV_16SC2);
+        Mat dstmap2 = new Mat(1, 3, CvType.CV_16UC1);
+
+        Imgproc.convertMaps(map1, map2, dstmap1, dstmap2, CvType.CV_16SC2, false);
+        // TODO_: write better test (last param == true)
+
+        Mat truthMap1 = new Mat(1, 3, CvType.CV_16SC2);
+        truthMap1.put(0, 0, 2, 4, 2, 4, 2, 4);
+        assertMatEqual(truthMap1, dstmap1);
+        Mat truthMap2 = new Mat(1, 3, CvType.CV_16UC1, new Scalar(0));
+        assertMatEqual(truthMap2, dstmap2);
+    }
+
+    public void testConvexHullMatMat() {
+        Mat points = new Mat(1, 6, CvType.CV_32FC2);
+        points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
+
+        Imgproc.convexHull(points, dst);
+
+        Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
+        expHull.put(0, 0, 4, 0, 3, 2, 0, 2, 2, 0);
+        assertMatEqual(expHull, dst, EPS);
+    }
+
+    public void testConvexHullMatMatBoolean() {
+        Mat points = new Mat(1, 6, CvType.CV_32FC2);
+        points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
+
+        Imgproc.convexHull(points, dst, true);
+
+        Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
+        expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
+        assertMatEqual(expHull, dst, EPS);
+    }
+
+    public void testConvexHullMatMatBooleanBoolean() {
+        Mat points = new Mat(1, 6, CvType.CV_32FC2);
+        points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
+
+        Imgproc.convexHull(points, dst, true, true);
+        // TODO_: write better test (last param == false)
+
+        Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
+        expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
+        assertMatEqual(expHull, dst, EPS);
+    }
+
+    public void testCopyMakeBorderMatMatIntIntIntIntInt() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
+        int border = 2;
+
+        Imgproc.copyMakeBorder(src, dst, border, border, border, border, Imgproc.BORDER_REPLICATE);
+
+        truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCopyMakeBorderMatMatIntIntIntIntIntScalar() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
+
+        Scalar value = new Scalar(0);
+        int border = 2;
+
+        Imgproc.copyMakeBorder(src, dst, border, border, border, border, Imgproc.BORDER_REPLICATE, value);
+        // TODO_: write better test (use Imgproc.BORDER_CONSTANT)
+
+        truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerEigenValsAndVecsMatMatIntInt() {
+        fail("Not yet implemented");
+        // TODO: write better test
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1);
+        src.put(0, 0, 1, 2);
+        src.put(1, 0, 4, 2);
+
+        int blockSize = 3;
+        int ksize = 5;
+
+        // TODO: eigen vals and vectors returned = 0 for most src matrices
+        Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize);
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC(6), new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerEigenValsAndVecsMatMatIntIntInt() {
+        fail("Not yet implemented");
+        // TODO: write better test
+        Mat src = new Mat(4, 4, CvType.CV_32FC1, new Scalar(128));
+
+        int blockSize = 3;
+        int ksize = 5;
+
+        truth = new Mat(4, 4, CvType.CV_32FC(6), new Scalar(0));
+
+        Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize, Imgproc.BORDER_REFLECT);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerHarrisMatMatIntIntDouble() {
+        fail("Not yet implemented");
+        // TODO: write better test
+
+        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
+        int blockSize = 5;
+        int ksize = 7;
+        double k = 0.1;
+        Imgproc.cornerHarris(gray128, dst, blockSize, ksize, k);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerHarrisMatMatIntIntDoubleInt() {
+        fail("Not yet implemented");
+        // TODO: write better test
+
+        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
+        int blockSize = 5;
+        int ksize = 7;
+        double k = 0.1;
+        Imgproc.cornerHarris(gray255, dst, blockSize, ksize, k, Imgproc.BORDER_REFLECT);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerMinEigenValMatMatInt() {
+        fail("Not yet implemented");
+        // TODO: write better test
+
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1);
+        src.put(0, 0, 1, 2);
+        src.put(1, 0, 2, 1);
+        int blockSize = 5;
+
+        Imgproc.cornerMinEigenVal(src, dst, blockSize);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+
+        Imgproc.cornerMinEigenVal(gray255, dst, blockSize);
+
+        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerMinEigenValMatMatIntInt() {
+        Mat src = Mat.eye(3, 3, CvType.CV_32FC1);
+        int blockSize = 3;
+        int ksize = 5;
+
+        Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize);
+
+        truth = new Mat(3, 3, CvType.CV_32FC1) {
+            {
+                put(0, 0, 1. / 18, 1. / 36, 1. / 18);
+                put(1, 0, 1. / 36, 1. / 18, 1. / 36);
+                put(2, 0, 1. / 18, 1. / 36, 1. / 18);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerMinEigenValMatMatIntIntInt() {
+        Mat src = Mat.eye(3, 3, CvType.CV_32FC1);
+        int blockSize = 3;
+        int ksize = 5;
+
+        Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(3, 3, CvType.CV_32FC1) {
+            {
+                put(0, 0, 0.68055558, 0.92708349, 0.5868057);
+                put(1, 0, 0.92708343, 0.92708343, 0.92708343);
+                put(2, 0, 0.58680564, 0.92708343, 0.68055564);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testCornerSubPix() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(128));
+        Point truthPosition = new Point(img.cols() / 2, img.rows() / 2);
+
+        Rect r = new Rect(new Point(0, 0), truthPosition);
+        Core.rectangle(img, r.tl(), r.br(), new Scalar(0), Core.FILLED);
+        List<Point> corners = new ArrayList<Point>();
+        corners.add(new Point(truthPosition.x + 1, truthPosition.y + 1));
+        Size winSize = new Size(2, 2);
+        Size zeroZone = new Size(-1, -1);
+        TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, 0.01);
+
+        Imgproc.cornerSubPix(img, corners, winSize, zeroZone, criteria);
+
+        assertPointEquals(truthPosition, corners.get(0), weakEPS);
+    }
+
+    public void testCvtColorMatMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvtColorMatMatIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDilateMatMatMat() {
+        Mat kernel = new Mat();
+
+        Imgproc.dilate(gray255, dst, kernel);
+
+        assertMatEqual(gray255, dst);
+
+        Imgproc.dilate(gray1, dst, kernel);
+
+        assertMatEqual(gray1, dst);
+        // TODO_: write better test
+    }
+
+    public void testDilateMatMatMatPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDilateMatMatMatPointInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDilateMatMatMatPointIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDilateMatMatMatPointIntIntScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDistanceTransform() {
+        Mat dstLables = getMat(CvType.CV_32SC1, 0);
+        Mat labels = new Mat();
+
+        Imgproc.distanceTransform(gray128, dst, labels, Imgproc.CV_DIST_L2, 3);
+
+        assertMatEqual(dstLables, labels);
+        assertMatEqual(getMat(CvType.CV_32FC1, 8192), dst, EPS);
+    }
+
+    public void testDrawContoursMatListOfMatIntScalar() {
+        Core.rectangle(gray0, new Point(1, 2), new Point(7, 8), new Scalar(100));
+        List<Mat> contours = new ArrayList<Mat>();
+        Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        Imgproc.drawContours(gray0, contours, -1, new Scalar(0));
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testDrawContoursMatListOfMatIntScalarInt() {
+        Core.rectangle(gray0, new Point(1, 2), new Point(7, 8), new Scalar(100));
+        List<Mat> contours = new ArrayList<Mat>();
+        Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        Imgproc.drawContours(gray0, contours, -1, new Scalar(0), Core.FILLED);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testDrawContoursMatListOfMatIntScalarIntInt() {
+        Core.rectangle(gray0, new Point(1, 2), new Point(7, 8), new Scalar(100));
+        List<Mat> contours = new ArrayList<Mat>();
+        Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        Imgproc.drawContours(gray0, contours, -1, new Scalar(0), Core.FILLED, Core.LINE_8);
+
+        assertEquals(0, Core.countNonZero(gray0));
+    }
+
+    public void testDrawContoursMatListOfMatIntScalarIntIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawContoursMatListOfMatIntScalarIntIntMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawContoursMatListOfMatIntScalarIntIntMatIntPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testEqualizeHist() {
+        Imgproc.equalizeHist(gray0, dst);
+        assertMatEqual(gray0, dst);
+
+        Imgproc.equalizeHist(gray255, dst);
+        assertMatEqual(gray255, dst);
+        // TODO_: write better test
+    }
+
+    public void testErodeMatMatMat() {
+        Mat kernel = new Mat();
+
+        Imgproc.erode(gray128, dst, kernel);
+
+        assertMatEqual(gray128, dst);
+    }
+
+    public void testErodeMatMatMatPoint() {
+        Mat src = new Mat(3, 3, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 4, 8);
+                put(1, 0, 2, 0, 1);
+                put(2, 0, 3, 4, 6);
+            }
+        };
+        Mat kernel = new Mat();
+
+        Imgproc.erode(src, dst, kernel, anchorPoint);
+
+        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(0));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testErodeMatMatMatPointInt() {
+        Mat src = new Mat(3, 3, CvType.CV_8U) {
+            {
+                put(0, 0, 15, 9, 10);
+                put(1, 0, 10, 8, 12);
+                put(2, 0, 12, 20, 25);
+            }
+        };
+        Mat kernel = new Mat();
+
+        Imgproc.erode(src, dst, kernel, anchorPoint, 10);
+
+        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testErodeMatMatMatPointIntInt() {
+        Mat src = new Mat(3, 3, CvType.CV_8U) {
+            {
+                put(0, 0, 15, 9, 10);
+                put(1, 0, 10, 8, 12);
+                put(2, 0, 12, 20, 25);
+            }
+        };
+        Mat kernel = new Mat();
+
+        Imgproc.erode(src, dst, kernel, anchorPoint, 10, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testErodeMatMatMatPointIntIntScalar() {
+        Mat src = new Mat(3, 3, CvType.CV_8U) {
+            {
+                put(0, 0, 15, 9, 10);
+                put(1, 0, 10, 8, 12);
+                put(2, 0, 12, 20, 25);
+            }
+        };
+        Mat kernel = new Mat();
+        Scalar sc = new Scalar(3, 3);
+
+        Imgproc.erode(src, dst, kernel, anchorPoint, 10, Imgproc.BORDER_REFLECT, sc);
+
+        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testFilter2DMatMatIntMat() {
+        Mat src = Mat.eye(4, 4, CvType.CV_32F);
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
+
+        Imgproc.filter2D(src, dst, -1, kernel);
+
+        truth = new Mat(4, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 2, 1, 0);
+                put(1, 0, 2, 2, 1, 0);
+                put(2, 0, 1, 1, 2, 1);
+                put(3, 0, 0, 0, 1, 2);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testFilter2DMatMatIntMatPoint() {
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
+        Point point = new Point(0, 0);
+
+        Imgproc.filter2D(gray128, dst, -1, kernel, point);
+
+        assertMatEqual(gray255, dst);
+    }
+
+    public void testFilter2DMatMatIntMatPointDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testFilter2DMatMatIntMatPointDoubleInt() {
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
+        Point point = new Point(0, 0);
+
+        Imgproc.filter2D(gray128, dst, -1, kernel, point, 2, Imgproc.BORDER_CONSTANT);
+
+        assertMatEqual(gray2, dst);
+    }
+
+    public void testFindContoursMatListOfMatMatIntInt() {
+        Mat img = new Mat(50, 50, CvType.CV_8UC1, new Scalar(0));
+        List<Mat> contours = new ArrayList<Mat>(5);
+        Mat hierarchy = new Mat();
+
+        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        // no contours on empty image
+        assertEquals(contours.size(), 0);
+        assertEquals(contours.size(), hierarchy.total());
+
+        Core.rectangle(img, new Point(10, 20), new Point(20, 30), new Scalar(100), 3, Core.LINE_AA);
+        Core.rectangle(img, new Point(30, 35), new Point(40, 45), new Scalar(200));
+
+        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+        // two contours of two rectangles
+        assertEquals(contours.size(), 2);
+        assertEquals(contours.size(), hierarchy.total());
+    }
+
+    public void testFindContoursMatListOfMatMatIntIntPoint() {
+        Mat img = new Mat(50, 50, CvType.CV_8UC1, new Scalar(0));
+        Mat img2 = img.submat(5, 50, 3, 50);
+        List<Mat> contours = new ArrayList<Mat>();
+        List<Mat> contours2 = new ArrayList<Mat>();
+
+        Core.rectangle(img, new Point(10, 20), new Point(20, 30), new Scalar(100), 3, Core.LINE_AA);
+        Core.rectangle(img, new Point(30, 35), new Point(40, 45), new Scalar(200));
+
+        Imgproc.findContours(img, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+        Imgproc.findContours(img2, contours2, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE, new Point(3, 5));
+
+        assertEquals(contours.size(), contours2.size());
+        assertMatEqual(contours.get(0), contours2.get(0));
+    }
+
+    public void testFitEllipse() {
+        List<Point> points = Arrays.asList(new Point(0, 0), new Point(-1, 1), new Point(1, 1), new Point(1, -1), new Point(-1, -1));
+        RotatedRect rrect = new RotatedRect();
+
+        rrect = Imgproc.fitEllipse(points);
+
+        assertPointEquals(new Point(0, 0), rrect.center, EPS);
+        assertEquals(2.53, rrect.size.width, EPS);
+        assertEquals(2.53, rrect.size.height, EPS);
+    }
+
+    public void testFitLine() {
+        Mat points = new Mat(1, 4, CvType.CV_32FC2);
+        points.put(0, 0, 0, 0, 2, 3, 3, 4, 5, 8);
+
+        Mat linePoints = new Mat(4, 1, CvType.CV_32FC1);
+        linePoints.put(0, 0, 0.53196341, 0.84676737, 2.496531, 3.7467217);
+
+        Imgproc.fitLine(points, dst, Imgproc.CV_DIST_L12, 0, 0.01, 0.01);
+
+        assertMatEqual(linePoints, dst, EPS);
+    }
+
+    public void testFloodFillMatMatPointScalar() {
+        Mat mask = new Mat(matSize + 2, matSize + 2, CvType.CV_8U, new Scalar(0));
+        Mat img = gray0;
+        Core.circle(mask, new Point(matSize / 2 + 1, matSize / 2 + 1), 3, new Scalar(2));
+
+        int retval = Imgproc.floodFill(img, mask, new Point(matSize / 2, matSize / 2), new Scalar(1));
+
+        assertEquals(Core.countNonZero(img), retval);
+        Core.circle(mask, new Point(matSize / 2 + 1, matSize / 2 + 1), 3, new Scalar(0));
+        assertEquals(retval + 4 * (matSize + 1), Core.countNonZero(mask));
+        assertMatEqual(mask.submat(1, matSize + 1, 1, matSize + 1), img);
+    }
+
+    public void testFloodFillMatMatPointScalar_WithoutMask() {
+        Mat img = gray0;
+        Core.circle(img, new Point(matSize / 2, matSize / 2), 3, new Scalar(2));
+
+        // TODO: ideally we should pass null instead of "new Mat()"
+        int retval = Imgproc.floodFill(img, new Mat(), new Point(matSize / 2, matSize / 2), new Scalar(1));
+
+        Core.circle(img, new Point(matSize / 2, matSize / 2), 3, new Scalar(0));
+        assertEquals(Core.countNonZero(img), retval);
+    }
+
+    public void testFloodFillMatMatPointScalarRect() {
+        fail("Not yet implemented");
+    }
+
+    public void testFloodFillMatMatPointScalarRectScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testFloodFillMatMatPointScalarRectScalarScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testFloodFillMatMatPointScalarRectScalarScalarInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testGaussianBlurMatMatSizeDouble() {
+        Imgproc.GaussianBlur(gray0, dst, size, 1);
+        assertMatEqual(gray0, dst);
+
+        Imgproc.GaussianBlur(gray2, dst, size, 1);
+        assertMatEqual(gray2, dst);
+    }
+
+    public void testGaussianBlurMatMatSizeDoubleDouble() {
+        Imgproc.GaussianBlur(gray2, dst, size, 0, 0);
+
+        assertMatEqual(gray2, dst);
+        // TODO_: write better test
+    }
+
+    public void testGaussianBlurMatMatSizeDoubleDoubleInt() {
+        Imgproc.GaussianBlur(gray2, dst, size, 1, 3, Imgproc.BORDER_REFLECT);
+
+        assertMatEqual(gray2, dst);
+        // TODO_: write better test
+    }
+
+    public void testGetAffineTransform() {
+        List<Point> src = Arrays.asList(new Point(2, 3), new Point(3, 1), new Point(1, 4));
+        List<Point> dst = Arrays.asList(new Point(3, 3), new Point(7, 4), new Point(5, 6));
+
+        Mat transform = Imgproc.getAffineTransform(src, dst);
+
+        Mat truth = new Mat(2, 3, CvType.CV_64FC1) {
+            {
+                put(0, 0, -8, -6, 37);
+                put(1, 0, -7, -4, 29);
+            }
+        };
+        assertMatEqual(truth, transform, EPS);
+    }
+
+    public void testGetDefaultNewCameraMatrixMat() {
+        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0);
+
+        assertFalse(mtx.empty());
+        assertEquals(0, Core.countNonZero(mtx));
+    }
+
+    public void testGetDefaultNewCameraMatrixMatSize() {
+        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0, size);
+
+        assertFalse(mtx.empty());
+        assertEquals(0, Core.countNonZero(mtx));
+        // TODO_: write better test
+    }
+
+    public void testGetDefaultNewCameraMatrixMatSizeBoolean() {
+        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0, size, true);
+
+        assertFalse(mtx.empty());
+        assertFalse(0 == Core.countNonZero(mtx));
+        // TODO_: write better test
+    }
+
+    public void testGetDerivKernelsMatMatIntIntInt() {
+        Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat expKx = new Mat(3, 1, CvType.CV_32F);
+        Mat expKy = new Mat(3, 1, CvType.CV_32F);
+        kx.put(0, 0, 1, 1);
+        kx.put(1, 0, 1, 1);
+        ky.put(0, 0, 2, 2);
+        ky.put(1, 0, 2, 2);
+        expKx.put(0, 0, 1, -2, 1);
+        expKy.put(0, 0, 1, -2, 1);
+
+        Imgproc.getDerivKernels(kx, ky, 2, 2, 3);
+
+        assertMatEqual(expKx, kx, EPS);
+        assertMatEqual(expKy, ky, EPS);
+    }
+
+    public void testGetDerivKernelsMatMatIntIntIntBoolean() {
+        Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat expKx = new Mat(3, 1, CvType.CV_32F);
+        Mat expKy = new Mat(3, 1, CvType.CV_32F);
+        kx.put(0, 0, 1, 1);
+        kx.put(1, 0, 1, 1);
+        ky.put(0, 0, 2, 2);
+        ky.put(1, 0, 2, 2);
+        expKx.put(0, 0, 1, -2, 1);
+        expKy.put(0, 0, 1, -2, 1);
+
+        Imgproc.getDerivKernels(kx, ky, 2, 2, 3, true);
+
+        assertMatEqual(expKx, kx, EPS);
+        assertMatEqual(expKy, ky, EPS);
+        // TODO_: write better test
+    }
+
+    public void testGetDerivKernelsMatMatIntIntIntBooleanInt() {
+        Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        Mat expKx = new Mat(3, 1, CvType.CV_32F);
+        Mat expKy = new Mat(3, 1, CvType.CV_32F);
+        kx.put(0, 0, 1, 1);
+        kx.put(1, 0, 1, 1);
+        ky.put(0, 0, 2, 2);
+        ky.put(1, 0, 2, 2);
+        expKx.put(0, 0, 1, -2, 1);
+        expKy.put(0, 0, 1, -2, 1);
+
+        Imgproc.getDerivKernels(kx, ky, 2, 2, 3, true, CvType.CV_32F);
+
+        assertMatEqual(expKx, kx, EPS);
+        assertMatEqual(expKy, ky, EPS);
+        // TODO_: write better test
+    }
+
+    public void testGetGaussianKernelIntDouble() {
+        dst = Imgproc.getGaussianKernel(1, 0.5);
+
+        truth = new Mat(1, 1, CvType.CV_64FC1, new Scalar(1));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testGetGaussianKernelIntDoubleInt() {
+        dst = Imgproc.getGaussianKernel(3, 0.8, CvType.CV_32F);
+
+        truth = new Mat(3, 1, CvType.CV_32F);
+        truth.put(0, 0, 0.23899426, 0.52201146, 0.23899426);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testGetPerspectiveTransform() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetRectSubPixMatSizePointMat() {
+        Size size = new Size(3, 3);
+        Point center = new Point(gray255.cols() / 2, gray255.rows() / 2);
+
+        Imgproc.getRectSubPix(gray255, size, center, dst);
+
+        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(255));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testGetRectSubPixMatSizePointMatInt() {
+        Mat src = new Mat(10, 10, CvType.CV_32F, new Scalar(2));
+        Size patchSize = new Size(5, 5);
+        Point center = new Point(src.cols() / 2, src.rows() / 2);
+
+        Imgproc.getRectSubPix(src, patchSize, center, dst);
+
+        truth = new Mat(5, 5, CvType.CV_32F, new Scalar(2));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testGetRotationMatrix2D() {
+        Point center = new Point(0, 0);
+
+        dst = Imgproc.getRotationMatrix2D(center, 0, 1);
+
+        truth = new Mat(2, 3, CvType.CV_64F) {
+            {
+                put(0, 0, 1, 0, 0);
+                put(1, 0, 0, 1, 0);
+            }
+        };
+
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testGetStructuringElementIntSize() {
+        dst = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, size);
+
+        truth = new Mat(3, 3, CvType.CV_8UC1, new Scalar(1));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testGetStructuringElementIntSizePoint() {
+        dst = Imgproc.getStructuringElement(Imgproc.MORPH_CROSS, size, anchorPoint);
+
+        truth = new Mat(3, 3, CvType.CV_8UC1) {
+            {
+                put(0, 0, 0, 0, 1);
+                put(1, 0, 0, 0, 1);
+                put(2, 0, 1, 1, 1);
+            }
+        };
+        assertMatEqual(truth, dst);
+    }
+
+    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDouble() {
+        Mat src = gray0;
+        Core.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
+        List<Point> lp = new ArrayList<Point>();
+
+        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3);
+
+        assertEquals(4, lp.size());
+    }
+
+    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMat() {
+        Mat src = gray128;
+        Point tl = new Point(2, 2);
+        Point br = new Point(8, 8);
+        Scalar color = new Scalar(100);
+        Core.rectangle(src, tl, br, color, -1);
+        Mat mask = gray0;
+        Core.circle(mask, tl, 3, color, -1);
+        List<Point> lp = new ArrayList<Point>();
+
+        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3, mask);
+
+        assertEquals(1, lp.size());
+    }
+
+    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMatInt() {
+        Mat src = gray0;
+        Core.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
+        List<Point> lp = new ArrayList<Point>();
+
+        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3, gray1, 4);
+
+        assertEquals(4, lp.size());
+    }
+
+    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMatIntBoolean() {
+        Mat src = gray0;
+        Core.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
+        List<Point> lp = new ArrayList<Point>();
+
+        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3, gray1, 4, true);
+
+        assertEquals(4, lp.size());
+    }
+
+    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMatIntBooleanDouble() {
+        Mat src = gray0;
+        Core.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
+        List<Point> lp = new ArrayList<Point>();
+
+        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3, gray1, 4, true, 0);
+
+        assertEquals(4, lp.size());
+    }
+
+    public void testGrabCutMatMatRectMatMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testGrabCutMatMatRectMatMatIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDouble() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
+
+        assertEquals(0, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDouble1() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+
+        Point center = new Point(img.cols() / 2, img.rows() / 2);
+        int radius = Math.min(img.cols() / 4, img.rows() / 4);
+        Core.circle(img, center, radius, colorBlack, 3);
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
+
+        assertEquals(1, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDouble() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+        double param1 = 50;
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4, param1);
+
+        assertEquals(0, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDouble1() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+        double param1 = 50;
+
+        Point center = new Point(img.cols() / 2, img.rows() / 2);
+        int radius = Math.min(img.cols() / 4, img.rows() / 4);
+        Core.circle(img, center, radius, colorBlack, 3);
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4, param1);
+
+        assertEquals(1, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDoubleDouble() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+        double param1 = 50;
+        double param2 = 100;
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4, param1, param2);
+
+        assertEquals(0, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDoubleDouble1() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat circles = new Mat();
+        double param1 = 50;
+        double param2 = 100;
+
+        Point center = new Point(img.cols() / 2, img.rows() / 2);
+        int radius = Math.min(img.cols() / 4, img.rows() / 4);
+        Core.circle(img, center, radius, colorBlack, 3);
+
+        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4, param1, param2);
+
+        assertEquals(1, circles.cols());
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughCirclesMatMatIntDoubleDoubleDoubleDoubleIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughLinesMatMatDoubleDoubleInt() {
+        int sz = 512;
+        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
+        Mat lines = new Mat();
+        Point point1 = new Point(50, 50);
+        Point point2 = new Point(img.cols() / 2, img.rows() / 2);
+        Core.line(img, point1, point2, colorBlack, 2);
+
+        Imgproc.HoughLines(img, lines, 1, 5, 1);
+
+        assertEquals(2, lines.cols());
+    }
+
+    public void testHoughLinesMatMatDoubleDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughLinesMatMatDoubleDoubleIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughLinesPMatMatDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughLinesPMatMatDoubleDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHoughLinesPMatMatDoubleDoubleIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHuMoments() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitUndistortRectifyMap() {
+        fail("Not yet implemented");
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
+        cameraMatrix.put(0, 0, 1, 0, 1);
+        cameraMatrix.put(1, 0, 0, 1, 1);
+        cameraMatrix.put(2, 0, 0, 0, 1);
+
+        Mat R = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
+        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+
+        Mat distCoeffs = new Mat();
+        Mat map1 = new Mat();
+        Mat map2 = new Mat();
+
+        // TODO: complete this test
+        Imgproc.initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, CvType.CV_32F, map1, map2);
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMat() {
+        fail("Not yet implemented");
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F);
+        // Size imageSize = new Size(2, 2);
+
+        cameraMatrix.put(0, 0, 1, 0, 1);
+        cameraMatrix.put(1, 0, 0, 1, 2);
+        cameraMatrix.put(2, 0, 0, 0, 1);
+
+        distCoeffs.put(0, 0, 1, 3, 2, 4);
+        truth = new Mat(3, 3, CvType.CV_32F);
+        truth.put(0, 0, 0, 0, 0);
+        truth.put(1, 0, 0, 0, 0);
+        truth.put(2, 0, 0, 3, 0);
+        // TODO: No documentation for this function
+        // Imgproc.initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize,
+        // 5, m1type, truthput1, truthput2);
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testInpaint() {
+        Core.circle(gray255, new Point(matSize / 2, matSize / 2), 2, colorBlack, Core.FILLED);
+        Core.circle(gray0, new Point(matSize / 2, matSize / 2), 2, colorWhite, Core.FILLED);
+
+        Imgproc.inpaint(gray255, gray0, dst, 3, Imgproc.INPAINT_TELEA);
+
+        assertMatEqual(getMat(CvType.CV_8U, 255), dst);
+    }
+
+    public void testIntegral2MatMatMat() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat expSum = new Mat(4, 4, CvType.CV_64F);
+        Mat expSqsum = new Mat(4, 4, CvType.CV_64F);
+        Mat sum = new Mat();
+        Mat sqsum = new Mat();
+
+        expSum.put(0, 0, 0, 0, 0, 0);
+        expSum.put(1, 0, 0, 3, 6, 9);
+        expSum.put(2, 0, 0, 6, 12, 18);
+        expSum.put(3, 0, 0, 9, 18, 27);
+
+        expSqsum.put(0, 0, 0, 0, 0, 0);
+        expSqsum.put(1, 0, 0, 9, 18, 27);
+        expSqsum.put(2, 0, 0, 18, 36, 54);
+        expSqsum.put(3, 0, 0, 27, 54, 81);
+
+        Imgproc.integral2(src, sum, sqsum);
+
+        assertMatEqual(expSum, sum, EPS);
+        assertMatEqual(expSqsum, sqsum, EPS);
+    }
+
+    public void testIntegral2MatMatMatInt() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat expSum = new Mat(4, 4, CvType.CV_64F);
+        Mat expSqsum = new Mat(4, 4, CvType.CV_64F);
+        Mat sum = new Mat();
+        Mat sqsum = new Mat();
+
+        expSum.put(0, 0, 0, 0, 0, 0);
+        expSum.put(1, 0, 0, 3, 6, 9);
+        expSum.put(2, 0, 0, 6, 12, 18);
+        expSum.put(3, 0, 0, 9, 18, 27);
+
+        expSqsum.put(0, 0, 0, 0, 0, 0);
+        expSqsum.put(1, 0, 0, 9, 18, 27);
+        expSqsum.put(2, 0, 0, 18, 36, 54);
+        expSqsum.put(3, 0, 0, 27, 54, 81);
+
+        Imgproc.integral2(src, sum, sqsum, CvType.CV_64F);
+
+        assertMatEqual(expSum, sum, EPS);
+        assertMatEqual(expSqsum, sqsum, EPS);
+    }
+
+    public void testIntegral3MatMatMatMat() {
+        Mat src = new Mat(1, 1, CvType.CV_32F, new Scalar(1));
+        Mat expSum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat expSqsum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat expTilted = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat sum = new Mat();
+        Mat sqsum = new Mat();
+        Mat tilted = new Mat();
+
+        expSum.put(0, 0, 0, 0);
+        expSum.put(1, 0, 0, 1);
+
+        expSqsum.put(0, 0, 0, 0);
+        expSqsum.put(1, 0, 0, 1);
+
+        expTilted.put(0, 0, 0, 0);
+        expTilted.put(1, 0, 0, 1);
+
+        Imgproc.integral3(src, sum, sqsum, tilted);
+
+        assertMatEqual(expSum, sum, EPS);
+        assertMatEqual(expSqsum, sqsum, EPS);
+        assertMatEqual(expTilted, tilted, EPS);
+    }
+
+    public void testIntegral3MatMatMatMatInt() {
+        Mat src = new Mat(1, 1, CvType.CV_32F, new Scalar(1));
+        Mat expSum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat expSqsum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat expTilted = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
+        Mat sum = new Mat();
+        Mat sqsum = new Mat();
+        Mat tilted = new Mat();
+
+        expSum.put(0, 0, 0, 0);
+        expSum.put(1, 0, 0, 1);
+
+        expSqsum.put(0, 0, 0, 0);
+        expSqsum.put(1, 0, 0, 1);
+
+        expTilted.put(0, 0, 0, 0);
+        expTilted.put(1, 0, 0, 1);
+
+        Imgproc.integral3(src, sum, sqsum, tilted, CvType.CV_64F);
+
+        assertMatEqual(expSum, sum, EPS);
+        assertMatEqual(expSqsum, sqsum, EPS);
+        assertMatEqual(expTilted, tilted, EPS);
+    }
+
+    public void testIntegralMatMat() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+
+        Imgproc.integral(src, dst);
+
+        truth = new Mat(3, 3, CvType.CV_64F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 2, 4);
+                put(2, 0, 0, 4, 8);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIntegralMatMatInt() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+
+        Imgproc.integral(src, dst, CvType.CV_64F);
+
+        truth = new Mat(3, 3, CvType.CV_64F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 2, 4);
+                put(2, 0, 0, 4, 8);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testInvertAffineTransform() {
+        Mat src = new Mat(2, 3, CvType.CV_64F, new Scalar(1));
+
+        Imgproc.invertAffineTransform(src, dst);
+
+        truth = new Mat(2, 3, CvType.CV_64F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testIsContourConvex() {
+        List<Point> contour1 = Arrays.asList(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
+
+        assertFalse(Imgproc.isContourConvex(contour1));
+
+        List<Point> contour2 = Arrays.asList(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
+
+        assertTrue(Imgproc.isContourConvex(contour2));
+    }
+
+    public void testLaplacianMatMatInt() {
+        Imgproc.Laplacian(gray0, dst, CvType.CV_8U);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testLaplacianMatMatIntInt() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
+        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(0));
+
+        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1);
+
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testLaplacianMatMatIntIntDouble() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
+
+        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
+            {
+                put(0, 0, -8, 8);
+                put(1, 0, 8, -8);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testLaplacianMatMatIntIntDoubleDouble() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
+
+        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
+            {
+                put(0, 0, -7.9990001, 8.0009995);
+                put(1, 0, 8.0009995, -7.9990001);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testLaplacianMatMatIntIntDoubleDoubleInt() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
+
+        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(0.00099945068));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMatchShapes() {
+        Mat contour1 = new Mat(1, 4, CvType.CV_32FC2);
+        Mat contour2 = new Mat(1, 4, CvType.CV_32FC2);
+        contour1.put(0, 0, 1, 1, 5, 1, 4, 3, 6, 2);
+        contour2.put(0, 0, 1, 1, 6, 1, 4, 1, 2, 5);
+
+        double distance = Imgproc.matchShapes(contour1, contour2, Imgproc.CV_CONTOURS_MATCH_I1, 1);
+
+        assertEquals(2.81109697365334, distance, EPS);
+    }
+
+    public void testMatchTemplate() {
+        Mat image = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
+        Mat templ = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
+        image.put(0, 0, 1, 2, 3, 4);
+        templ.put(0, 0, 5, 6, 7, 8);
+
+        Imgproc.matchTemplate(image, templ, dst, Imgproc.TM_CCORR);
+
+        truth = new Mat(1, 1, CvType.CV_32F, new Scalar(70));
+        assertMatEqual(truth, dst, EPS);
+
+        Imgproc.matchTemplate(gray255, gray0, dst, Imgproc.TM_CCORR);
+
+        truth = new Mat(1, 1, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testMedianBlur() {
+        Imgproc.medianBlur(gray255, dst, 5);
+        assertMatEqual(gray255, dst);
+
+        Imgproc.medianBlur(gray2, dst, 3);
+        assertMatEqual(gray2, dst);
+        // TODO_: write better test
+    }
+
+    public void testMinAreaRect() {
+        List<Point> points = Arrays.asList(new Point(1, 1), new Point(5, 1), new Point(4, 3), new Point(6, 2));
+
+        RotatedRect rrect = Imgproc.minAreaRect(points);
+
+        assertEquals(new Size(2, 5), rrect.size);
+        assertEquals(-90., rrect.angle);
+        assertEquals(new Point(3.5, 2), rrect.center);
+    }
+
+    public void testMinEnclosingCircle() {
+        List<Point> points = new ArrayList<Point>();
+        points.add(new Point(0, 0));
+        points.add(new Point(-1, 0));
+        points.add(new Point(0, -1));
+        points.add(new Point(1, 0));
+        points.add(new Point(0, 1));
+        Point actualCenter = new Point();
+        float[] radius = new float[1];
+
+        Imgproc.minEnclosingCircle(points, actualCenter, radius);
+
+        assertEquals(new Point(0, 0), actualCenter);
+        assertEquals(1.03f, radius[0], EPS);
+    }
+
+    public void testMomentsMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMomentsMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMorphologyExMatMatIntMat() {
+        Imgproc.morphologyEx(gray255, dst, Imgproc.MORPH_GRADIENT, gray0);
+
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testMorphologyExMatMatIntMatPoint() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(0));
+        Point point = new Point(0, 0);
+
+        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_OPEN, kernel, point);
+
+        truth = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
+        assertMatEqual(truth, dst);
+        // TODO_: write better test
+    }
+
+    public void testMorphologyExMatMatIntMatPointInt() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
+
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(0));
+        Point point = new Point(0, 0);
+
+        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_CLOSE, kernel, point, 10);
+
+        truth = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
+        assertMatEqual(truth, dst);
+        // TODO_: write better test
+    }
+
+    public void testMorphologyExMatMatIntMatPointIntInt() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
+        src.put(0, 0, 2, 1);
+        src.put(1, 0, 2, 1);
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(1));
+        Point point = new Point(1, 1);
+
+        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel, point, 10, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 0);
+                put(1, 0, 1, 0);
+            }
+        };
+        assertMatEqual(truth, dst);
+    }
+
+    public void testMorphologyExMatMatIntMatPointIntIntScalar() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
+        src.put(0, 0, 2, 1);
+        src.put(1, 0, 2, 1);
+
+        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(1));
+        Point point = new Point(1, 1);
+        Scalar sc = new Scalar(3, 3);
+
+        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel, point, 10, Imgproc.BORDER_REFLECT, sc);
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_8U) {
+            {
+                put(0, 0, 1, 0);
+                put(1, 0, 1, 0);
+            }
+        };
+        assertMatEqual(truth, dst);
+        // TODO_: write better test
+    }
+
+    public void testPointPolygonTest() {
+        List<Point> contour = Arrays.asList(new Point(0, 0), new Point(1, 3), new Point(3, 4), new Point(4, 3), new Point(2, 1));
+
+        double sign1 = Imgproc.pointPolygonTest(contour, new Point(2, 2), false);
+        assertEquals(1.0, sign1);
+
+        double sign2 = Imgproc.pointPolygonTest(contour, new Point(4, 4), true);
+        assertEquals(-Math.sqrt(0.5), sign2);
+    }
+
+    public void testPreCornerDetectMatMatInt() {
+        Mat src = new Mat(4, 4, CvType.CV_32F, new Scalar(1));
+        int ksize = 3;
+
+        Imgproc.preCornerDetect(src, dst, ksize);
+
+        truth = new Mat(4, 4, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testPreCornerDetectMatMatIntInt() {
+        Mat src = new Mat(4, 4, CvType.CV_32F, new Scalar(1));
+        int ksize = 3;
+
+        Imgproc.preCornerDetect(src, dst, ksize, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(4, 4, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+        // TODO_: write better test
+    }
+
+    public void testPyrDownMatMat() {
+        Mat src = new Mat(4, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 1, 4, 2);
+                put(1, 0, 3, 2, 6, 8);
+                put(2, 0, 4, 6, 8, 10);
+                put(3, 0, 12, 32, 6, 18);
+            }
+        };
+
+        Imgproc.pyrDown(src, dst);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
+            {
+                put(0, 0, 2.78125, 4.609375);
+                put(1, 0, 8.546875, 8.8515625);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testPyrDownMatMatSize() {
+        Mat src = new Mat(4, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 1, 4, 2);
+                put(1, 0, 3, 2, 6, 8);
+                put(2, 0, 4, 6, 8, 10);
+                put(3, 0, 12, 32, 6, 18);
+            }
+        };
+        Size dstSize = new Size(2, 2);
+
+        Imgproc.pyrDown(src, dst, dstSize);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
+            {
+                put(0, 0, 2.78125, 4.609375);
+                put(1, 0, 8.546875, 8.8515625);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+        // TODO_: write better test
+    }
+
+    public void testPyrMeanShiftFilteringMatMatDoubleDouble() {
+        Mat src = new Mat(matSize, matSize, CvType.CV_8UC3, new Scalar(0));
+
+        Imgproc.pyrMeanShiftFiltering(src, dst, 10, 50);
+
+        assertMatEqual(src, dst);
+        // TODO_: write better test
+    }
+
+    public void testPyrMeanShiftFilteringMatMatDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testPyrMeanShiftFilteringMatMatDoubleDoubleIntTermCriteria() {
+        fail("Not yet implemented");
+    }
+
+    public void testPyrUpMatMat() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
+        src.put(0, 0, 2, 1);
+        src.put(1, 0, 3, 2);
+
+        Imgproc.pyrUp(src, dst);
+
+        truth = new Mat(4, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 1.75, 1.375, 1.25);
+                put(1, 0, 2.25, 2, 1.625, 1.5);
+                put(2, 0, 2.5, 2.25, 1.875, 1.75);
+                put(3, 0, 2.25, 2, 1.625, 1.5);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testPyrUpMatMatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testRemapMatMatMatMatInt() {
+        fail("Not yet implemented");
+        // this test does something weird
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+        Mat map1 = new Mat(1, 3, CvType.CV_32FC1);
+        Mat map2 = new Mat(1, 3, CvType.CV_32FC1);
+
+        map1.put(0, 0, 3, 6, 5);
+        map2.put(0, 0, 4, 8, 12);
+
+        Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR);
+
+        truth = new Mat(1, 3, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testRemapMatMatMatMatIntInt() {
+        fail("Not yet implemented");
+        // this test does something weird
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+        Mat map1 = new Mat(1, 3, CvType.CV_32FC1);
+        Mat map2 = new Mat(1, 3, CvType.CV_32FC1);
+
+        map1.put(0, 0, 3, 6, 5, 0);
+        map2.put(0, 0, 4, 8, 12);
+
+        truth = new Mat(1, 3, CvType.CV_32F, new Scalar(2));
+
+        Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR, Imgproc.BORDER_REFLECT);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testRemapMatMatMatMatIntIntScalar() {
+        fail("Not yet implemented");
+        // this test does something weird
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+        Mat map1 = new Mat(1, 3, CvType.CV_32FC1);
+        Mat map2 = new Mat(1, 3, CvType.CV_32FC1);
+
+        Scalar sc = new Scalar(0);
+
+        map1.put(0, 0, 3, 6, 5, 0);
+        map2.put(0, 0, 4, 8, 12);
+
+        truth = new Mat(1, 3, CvType.CV_32F, new Scalar(2));
+
+        Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR, Imgproc.BORDER_REFLECT, sc);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testResizeMatMatSize() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8UC1, new Scalar(1));
+        Size dsize = new Size(1, 1);
+
+        Imgproc.resize(src, dst, dsize);
+
+        truth = new Mat(1, 1, CvType.CV_8UC1, new Scalar(1));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testResizeMatMatSizeDouble() {
+        try {
+            Imgproc.resize(gray255, dst, new Size(), 0.5);
+            fail("Expected CvException was not thrown");
+        } catch (CvException e) {
+            // expected
+        }
+    }
+
+    public void testResizeMatMatSizeDoubleDouble() {
+        Imgproc.resize(gray255, dst, new Size(), 0.5, 0.5);
+
+        truth = new Mat((int) (matSize * 0.5), (int) (matSize * 0.5), CvType.CV_8U, new Scalar(255));
+        assertMatEqual(truth, dst);
+    }
+
+    public void testResizeMatMatSizeDoubleDoubleInt() {
+        Imgproc.resize(gray255, dst, new Size(2, 2), 0, 0, Imgproc.INTER_AREA);
+
+        truth = new Mat(2, 2, CvType.CV_8UC1, new Scalar(255));
+        assertMatEqual(truth, dst);
+        // TODO_: write better test
+    }
+
+    public void testScharrMatMatIntIntInt() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
+
+        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testScharrMatMatIntIntIntDouble() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
+
+        Imgproc.Scharr(src, dst, CvType.CV_32F, 0, 1, 1.5);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
+        assertMatEqual(truth, dst, EPS);
+        // TODO_: write better test
+    }
+
+    public void testScharrMatMatIntIntIntDoubleDouble() {
+        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
+
+        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0.001);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0.001));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testScharrMatMatIntIntIntDoubleDoubleInt() {
+        Mat src = Mat.eye(3, 3, CvType.CV_32F);
+
+        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, -15, -19.5, -4.5);
+                put(1, 0, 10.5, 0, -10.5);
+                put(2, 0, 4.5, 19.5, 15);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testSepFilter2DMatMatIntMatMat() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
+        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
+        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
+        kernelX.put(0, 0, 4, 3, 7);
+        kernelY.put(0, 0, 9, 4, 2);
+
+        Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(420));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testSepFilter2DMatMatIntMatMatPoint() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(2));
+        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
+        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
+        kernelX.put(0, 0, 2, 2, 2);
+        kernelY.put(0, 0, 1, 1, 1);
+
+        Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(36));
+        assertMatEqual(truth, dst, EPS);
+        // TODO_: write better test
+    }
+
+    public void testSepFilter2DMatMatIntMatMatPointDouble() {
+        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(2));
+        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
+        kernelX.put(0, 0, 2, 2, 2);
+        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
+        kernelY.put(0, 0, 1, 1, 1);
+
+        Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS);
+
+        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(36 + weakEPS));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testSepFilter2DMatMatIntMatMatPointDoubleInt() {
+        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
+        kernelX.put(0, 0, 2, 2, 2);
+
+        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
+        kernelY.put(0, 0, 1, 1, 1);
+
+        Imgproc.sepFilter2D(gray0, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS, Imgproc.BORDER_REFLECT);
+
+        truth = new Mat(10, 10, CvType.CV_32F, new Scalar(weakEPS));
+        assertMatEqual(truth, dst, EPS);
+        // TODO_: write better test
+    }
+
+    public void testSobelMatMatIntIntInt() {
+        Imgproc.Sobel(gray255, dst, CvType.CV_8U, 1, 0);
+
+        assertMatEqual(gray0, dst);
+    }
+
+    public void testSobelMatMatIntIntIntInt() {
+        Imgproc.Sobel(gray255, dst, CvType.CV_8U, 1, 0, 3);
+
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testSobelMatMatIntIntIntIntDouble() {
+        Mat src = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 0, 1);
+                put(1, 0, 3, 0, -10);
+                put(2, 0, -4, 0, 3);
+            }
+        };
+
+        Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2);
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0, -56, 0);
+                put(1, 0, 0, -40, 0);
+                put(2, 0, 0, -24, 0);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testSobelMatMatIntIntIntIntDoubleDouble() {
+        Imgproc.Sobel(gray255, dst, CvType.CV_8U, 1, 0, 3, 2, 0.001);
+        assertMatEqual(gray0, dst);
+        // TODO_: write better test
+    }
+
+    public void testSobelMatMatIntIntIntIntDoubleDoubleInt() {
+        Mat src = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 0, 1);
+                put(1, 0, 6, 4, 3);
+                put(2, 0, 1, 0, 2);
+            }
+        };
+
+        Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2, 0, Imgproc.BORDER_REPLICATE);
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, -16, -12, 4);
+                put(1, 0, -14, -12, 2);
+                put(2, 0, -10, 0, 10);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testThreshold() {
+        Imgproc.threshold(makeMask(gray0.clone(), 10), dst, 5, 255, Imgproc.THRESH_TRUNC);
+        assertMatEqual(makeMask(gray0.clone(), 5), dst);
+
+        Imgproc.threshold(makeMask(gray2.clone(), 10), dst, 1, 255, Imgproc.THRESH_BINARY);
+        assertMatEqual(gray255, dst);
+
+        Imgproc.threshold(makeMask(gray2.clone(), 10), dst, 3, 255, Imgproc.THRESH_BINARY_INV);
+        assertMatEqual(makeMask(gray255.clone(), 0), dst);
+    }
+
+    public void testUndistortMatMatMatMat() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 2);
+                put(2, 0, 0, 0, 1);
+            }
+        };
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 3, 2, 4);
+            }
+        };
+
+        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs);
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 0, 0);
+                put(2, 0, 0, 3, 0);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testUndistortMatMatMatMatMat() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 2);
+                put(2, 0, 0, 0, 1);
+            }
+        };
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 1, 4, 5);
+            }
+        };
+        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(1));
+
+        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix);
+
+        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testWarpAffineMatMatMatSize() {
+        Mat src = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 0, 1);
+                put(1, 0, 6, 4, 3);
+                put(2, 0, 1, 0, 2);
+            }
+        };
+        Mat M = new Mat(2, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 1);
+            }
+        };
+
+        Imgproc.warpAffine(src, dst, M, new Size(3, 3));
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 2, 0);
+                put(2, 0, 0, 6, 4);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testWarpAffineMatMatMatSizeInt() {
+        Mat src = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 1);
+                put(1, 0, 6, 4, 3);
+                put(2, 0, 0, 2, 2);
+            }
+        };
+        Mat M = new Mat(2, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 0);
+                put(1, 0, 0, 0, 1);
+            }
+        };
+
+        Imgproc.warpAffine(src, dst, M, new Size(2, 2), Imgproc.WARP_INVERSE_MAP);
+
+        truth = new Mat(2, 2, CvType.CV_32F) {
+            {
+                put(0, 0, 6, 4);
+                put(1, 0, 6, 4);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testWarpAffineMatMatMatSizeIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testWarpAffineMatMatMatSizeIntIntScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testWarpPerspectiveMatMatMatSize() {
+        Mat src = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 4, 1);
+                put(1, 0, 0, 4, 5);
+                put(2, 0, 1, 2, 2);
+            }
+        };
+        Mat M = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 1);
+                put(2, 0, 0, 0, 1);
+            }
+        };
+
+        Imgproc.warpPerspective(src, dst, M, new Size(3, 3));
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 2, 4);
+                put(2, 0, 0, 0, 4);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testWarpPerspectiveMatMatMatSizeInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testWarpPerspectiveMatMatMatSizeIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testWarpPerspectiveMatMatMatSizeIntIntScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testWatershed() {
+        Mat image = Mat.eye(4, 4, CvType.CV_8UC(3));
+        Mat markers = new Mat(4, 4, CvType.CV_32SC1, new Scalar(0));
+
+        Imgproc.watershed(image, markers);
+
+        truth = new Mat(4, 4, CvType.CV_32SC1) {
+            {
+                put(0, 0, -1, -1, -1, -1);
+                put(1, 0, -1, 0, 0, -1);
+                put(2, 0, -1, 0, 0, -1);
+                put(3, 0, -1, -1, -1, -1);
+            }
+        };
+        assertMatEqual(truth, markers);
+    }
+
+}
\ No newline at end of file
diff --git a/modules/java/android_test/src/org/opencv/test/imgproc/MomentsTest.java b/modules/java/android_test/src/org/opencv/test/imgproc/MomentsTest.java
new file mode 100644
index 0000000000..f62071fc45
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/imgproc/MomentsTest.java
@@ -0,0 +1,199 @@
+package org.opencv.test.imgproc;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class MomentsTest extends OpenCVTestCase {
+
+    public void testGet_m00() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m01() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m02() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m03() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m10() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m11() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m12() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m20() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m21() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_m30() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu02() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu03() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu11() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu12() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu20() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu21() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_mu30() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu02() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu03() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu11() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu12() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu20() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu21() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu30() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m00() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m01() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m02() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m03() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m10() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m11() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m12() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m20() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m21() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_m30() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu02() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu03() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu11() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu12() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu20() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu21() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_mu30() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu02() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu03() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu11() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu12() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu20() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu21() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu30() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/imgproc/Subdiv2DTest.java b/modules/java/android_test/src/org/opencv/test/imgproc/Subdiv2DTest.java
new file mode 100644
index 0000000000..7ba8fdda9f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/imgproc/Subdiv2DTest.java
@@ -0,0 +1,95 @@
+package org.opencv.test.imgproc;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class Subdiv2DTest extends OpenCVTestCase {
+
+    protected void setUp() throws Exception {
+        super.setUp();
+    }
+
+    public void testEdgeDstInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testEdgeDstIntPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testEdgeOrgInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testEdgeOrgIntPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindNearestPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testFindNearestPointPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetEdge() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetEdgeList() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTriangleList() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetVertexInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetVertexIntIntArray() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetVoronoiFacetList() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitDelaunay() {
+        fail("Not yet implemented");
+    }
+
+    public void testInsertListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testInsertPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testLocate() {
+        fail("Not yet implemented");
+    }
+
+    public void testNextEdge() {
+        fail("Not yet implemented");
+    }
+
+    public void testRotateEdge() {
+        fail("Not yet implemented");
+    }
+
+    public void testSubdiv2D() {
+        fail("Not yet implemented");
+    }
+
+    public void testSubdiv2DRect() {
+        fail("Not yet implemented");
+    }
+
+    public void testSymEdge() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLPTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLPTest.java
new file mode 100644
index 0000000000..709b631f86
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLPTest.java
@@ -0,0 +1,69 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvANN_MLP;
+
+import junit.framework.TestCase;
+
+public class CvANN_MLPTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreateMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreateMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreateMatIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreateMatIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvANN_MLP() {
+        new CvANN_MLP();
+    }
+
+    public void testCvANN_MLPMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvANN_MLPMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvANN_MLPMatIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvANN_MLPMatIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredict() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMatCvANN_MLP_TrainParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMatCvANN_MLP_TrainParamsInt() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLP_TrainParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLP_TrainParamsTest.java
new file mode 100644
index 0000000000..dd4a8f3598
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvANN_MLP_TrainParamsTest.java
@@ -0,0 +1,77 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvANN_MLP_TrainParams;
+
+import junit.framework.TestCase;
+
+public class CvANN_MLP_TrainParamsTest extends TestCase {
+
+    public void testCvANN_MLP_TrainParams() {
+        new CvANN_MLP_TrainParams();
+    }
+
+    public void testGet_bp_dw_scale() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_bp_moment_scale() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_rp_dw_max() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_rp_dw_min() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_rp_dw_minus() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_rp_dw_plus() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_rp_dw0() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_train_method() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_bp_dw_scale() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_bp_moment_scale() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_rp_dw_max() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_rp_dw_min() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_rp_dw_minus() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_rp_dw_plus() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_rp_dw0() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_train_method() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvBoostParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvBoostParamsTest.java
new file mode 100644
index 0000000000..3d815bcbc9
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvBoostParamsTest.java
@@ -0,0 +1,45 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvBoostParams;
+
+import junit.framework.TestCase;
+
+public class CvBoostParamsTest extends TestCase {
+
+    public void testCvBoostParams() {
+        new CvBoostParams();
+    }
+
+    public void testGet_boost_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_split_criteria() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_weak_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_weight_trim_rate() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_boost_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_split_criteria() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_weak_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_weight_trim_rate() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvBoostTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvBoostTest.java
new file mode 100644
index 0000000000..466d64a63a
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvBoostTest.java
@@ -0,0 +1,93 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvBoost;
+
+import junit.framework.TestCase;
+
+public class CvBoostTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoost() {
+        new CvBoost();
+    }
+
+    public void testCvBoostMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoostMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoostMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoostMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoostMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvBoostMatIntMatMatMatMatMatCvBoostParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMatRange() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMatRangeBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMatRangeBooleanBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testPrune() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvBoostParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvBoostParamsBoolean() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvDTreeParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvDTreeParamsTest.java
new file mode 100644
index 0000000000..e767aaec28
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvDTreeParamsTest.java
@@ -0,0 +1,77 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvDTreeParams;
+
+import junit.framework.TestCase;
+
+public class CvDTreeParamsTest extends TestCase {
+
+    public void testCvDTreeParams() {
+        new CvDTreeParams();
+    }
+
+    public void testGet_cv_folds() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_max_categories() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_max_depth() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_min_sample_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_regression_accuracy() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_truncate_pruned_tree() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_use_1se_rule() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_use_surrogates() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_cv_folds() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_max_categories() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_max_depth() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_min_sample_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_regression_accuracy() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_truncate_pruned_tree() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_use_1se_rule() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_use_surrogates() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvDTreeTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvDTreeTest.java
new file mode 100644
index 0000000000..f6a5baa60b
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvDTreeTest.java
@@ -0,0 +1,45 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvDTree;
+
+import junit.framework.TestCase;
+
+public class CvDTreeTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvDTree() {
+        new CvDTree();
+    }
+
+    public void testGetVarImportance() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvDTreeParams() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvEMParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvEMParamsTest.java
new file mode 100644
index 0000000000..2b2b9f0a68
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvEMParamsTest.java
@@ -0,0 +1,37 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvEMParams;
+
+import junit.framework.TestCase;
+
+public class CvEMParamsTest extends TestCase {
+
+    public void testCvEMParams() {
+        new CvEMParams();
+    }
+
+    public void testGet_cov_mat_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nclusters() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_start_step() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_cov_mat_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nclusters() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_start_step() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvEMTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvEMTest.java
new file mode 100644
index 0000000000..b649653558
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvEMTest.java
@@ -0,0 +1,85 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvEM;
+
+import junit.framework.TestCase;
+
+public class CvEMTest extends TestCase {
+
+    public void testCalcLikelihood() {
+        fail("Not yet implemented");
+    }
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvEM() {
+        new CvEM();
+    }
+
+    public void testCvEMMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvEMMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvEMMatMatCvEMParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetCovs() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetLikelihood() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetLikelihoodDelta() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetMeans() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetNClusters() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetProbs() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetWeights() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatCvEMParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatCvEMParamsMat() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvERTreesTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvERTreesTest.java
new file mode 100644
index 0000000000..0a59dfec85
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvERTreesTest.java
@@ -0,0 +1,37 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvERTrees;
+
+import junit.framework.TestCase;
+
+public class CvERTreesTest extends TestCase {
+
+    public void testCvERTrees() {
+        new CvERTrees();
+    }
+
+    public void testTrainMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvRTParams() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesParamsTest.java
new file mode 100644
index 0000000000..ca266d1b1c
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesParamsTest.java
@@ -0,0 +1,45 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvGBTreesParams;
+
+import junit.framework.TestCase;
+
+public class CvGBTreesParamsTest extends TestCase {
+
+    public void testCvGBTreesParams() {
+        new CvGBTreesParams();
+    }
+
+    public void testGet_loss_function_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_shrinkage() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_subsample_portion() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_weak_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_loss_function_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_shrinkage() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_subsample_portion() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_weak_count() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesTest.java
new file mode 100644
index 0000000000..2bbb38d450
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvGBTreesTest.java
@@ -0,0 +1,85 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvGBTrees;
+
+import junit.framework.TestCase;
+
+public class CvGBTreesTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTrees() {
+        new CvGBTrees();
+    }
+
+    public void testCvGBTreesMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTreesMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTreesMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTreesMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTreesMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvGBTreesMatIntMatMatMatMatMatCvGBTreesParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMatRange() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMatRangeInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvGBTreesParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvGBTreesParamsBoolean() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvKNearestTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvKNearestTest.java
new file mode 100644
index 0000000000..1f7bd37dde
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvKNearestTest.java
@@ -0,0 +1,53 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvKNearest;
+
+import junit.framework.TestCase;
+
+public class CvKNearestTest extends TestCase {
+
+    public void testCvKNearest() {
+        new CvKNearest();
+    }
+
+    public void testCvKNearestMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvKNearestMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvKNearestMatMatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvKNearestMatMatMatBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testFind_nearest() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatBooleanIntBoolean() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvNormalBayesClassifierTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvNormalBayesClassifierTest.java
new file mode 100644
index 0000000000..d184a79235
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvNormalBayesClassifierTest.java
@@ -0,0 +1,53 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvNormalBayesClassifier;
+
+import junit.framework.TestCase;
+
+public class CvNormalBayesClassifierTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvNormalBayesClassifier() {
+        new CvNormalBayesClassifier();
+    }
+
+    public void testCvNormalBayesClassifierMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvNormalBayesClassifierMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvNormalBayesClassifierMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvParamGridTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvParamGridTest.java
new file mode 100644
index 0000000000..39334d15e0
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvParamGridTest.java
@@ -0,0 +1,37 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvParamGrid;
+
+import junit.framework.TestCase;
+
+public class CvParamGridTest extends TestCase {
+
+    public void testCvParamGrid() {
+        new CvParamGrid();
+    }
+
+    public void testGet_max_val() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_min_val() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_step() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_max_val() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_min_val() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_step() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvRTParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvRTParamsTest.java
new file mode 100644
index 0000000000..fb12e9a0e1
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvRTParamsTest.java
@@ -0,0 +1,29 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvRTParams;
+
+import junit.framework.TestCase;
+
+public class CvRTParamsTest extends TestCase {
+
+    public void testCvRTParams() {
+        new CvRTParams();
+    }
+
+    public void testGet_calc_var_importance() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nactive_vars() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_calc_var_importance() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nactive_vars() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvRTreesTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvRTreesTest.java
new file mode 100644
index 0000000000..dcb88eff08
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvRTreesTest.java
@@ -0,0 +1,61 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvRTrees;
+
+import junit.framework.TestCase;
+
+public class CvRTreesTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvRTrees() {
+        new CvRTrees();
+    }
+
+    public void testGetVarImportance() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredict_probMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredict_probMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatIntMatMatMatMatMatCvRTParams() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvSVMParamsTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvSVMParamsTest.java
new file mode 100644
index 0000000000..a1b4c92100
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvSVMParamsTest.java
@@ -0,0 +1,77 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvSVMParams;
+
+import junit.framework.TestCase;
+
+public class CvSVMParamsTest extends TestCase {
+
+    public void testCvSVMParams() {
+        new CvSVMParams();
+    }
+
+    public void testGet_C() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_coef0() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_degree() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_gamma() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_kernel_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nu() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_p() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_svm_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_C() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_coef0() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_degree() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_gamma() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_kernel_type() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_nu() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_p() {
+        fail("Not yet implemented");
+    }
+
+    public void testSet_svm_type() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvSVMTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvSVMTest.java
new file mode 100644
index 0000000000..4982ee85d9
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvSVMTest.java
@@ -0,0 +1,101 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvSVM;
+
+import junit.framework.TestCase;
+
+public class CvSVMTest extends TestCase {
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvSVM() {
+        new CvSVM();
+    }
+
+    public void testCvSVMMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvSVMMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvSVMMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCvSVMMatMatMatMatCvSVMParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_support_vector_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_var_count() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParams() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridCvParamGrid() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain_autoMatMatMatMatCvSVMParamsIntCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridCvParamGridBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrainMatMatMatMatCvSVMParams() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/ml/CvStatModelTest.java b/modules/java/android_test/src/org/opencv/test/ml/CvStatModelTest.java
new file mode 100644
index 0000000000..a732bc5506
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/ml/CvStatModelTest.java
@@ -0,0 +1,29 @@
+package org.opencv.test.ml;
+
+import org.opencv.ml.CvStatModel;
+
+import junit.framework.TestCase;
+
+public class CvStatModelTest extends TestCase {
+
+    public void testCvStatModel() {
+        new CvStatModel();
+    }
+
+    public void testLoadString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadStringString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveStringString() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/objdetect/CascadeClassifierTest.java b/modules/java/android_test/src/org/opencv/test/objdetect/CascadeClassifierTest.java
new file mode 100644
index 0000000000..6a993c03b7
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/objdetect/CascadeClassifierTest.java
@@ -0,0 +1,106 @@
+package org.opencv.test.objdetect;
+
+import java.util.ArrayList;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Rect;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.objdetect.CascadeClassifier;
+import org.opencv.objdetect.Objdetect;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class CascadeClassifierTest extends OpenCVTestCase {
+
+    private CascadeClassifier cc;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        cc = null;
+    }
+
+    public void testCascadeClassifier() {
+        cc = new CascadeClassifier();
+        assertTrue(null != cc);
+    }
+
+    public void testCascadeClassifierString() {
+        cc = new CascadeClassifier(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        assertTrue(null != cc);
+    }
+
+    public void testDetectMultiScaleMatListOfRect() {
+        CascadeClassifier cc = new CascadeClassifier(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        ArrayList<Rect> faces = new ArrayList<Rect>();
+
+        Mat greyLena = new Mat();
+        Imgproc.cvtColor(rgbLena, greyLena, Imgproc.COLOR_RGB2GRAY);
+
+        // TODO: doesn't detect with 1.1 scale
+        cc.detectMultiScale(greyLena, faces, 1.09, 3, Objdetect.CASCADE_SCALE_IMAGE, new Size(30, 30));
+        assertEquals(1, faces.size());
+    }
+
+    public void testDetectMultiScaleMatListOfRectDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntIntSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleIntIntSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfIntegerListOfDoubleDoubleIntIntSizeSizeBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        cc = new CascadeClassifier();
+        assertTrue(cc.empty());
+    }
+
+    public void testLoad() {
+        cc = new CascadeClassifier();
+        cc.load(OpenCVTestRunner.LBPCASCADE_FRONTALFACE_PATH);
+        assertTrue(!cc.empty());
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/objdetect/HOGDescriptorTest.java b/modules/java/android_test/src/org/opencv/test/objdetect/HOGDescriptorTest.java
new file mode 100644
index 0000000000..01ec4575ad
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/objdetect/HOGDescriptorTest.java
@@ -0,0 +1,259 @@
+package org.opencv.test.objdetect;
+
+import org.opencv.objdetect.HOGDescriptor;
+import org.opencv.test.OpenCVTestCase;
+
+public class HOGDescriptorTest extends OpenCVTestCase {
+
+    public void testCheckDetectorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeGradientMatMatMatSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfFloatSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointDoubleSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfPointListOfDoubleDoubleSizeSizeListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRect() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectDoubleSizeSizeDoubleDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMultiScaleMatListOfRectListOfDoubleDoubleSizeSizeDoubleDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_blockSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_blockStride() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_cellSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_derivAperture() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_gammaCorrection() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_histogramNormType() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_L2HysThreshold() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nbins() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_nlevels() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_svmDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_winSigma() {
+        fail("Not yet implemented");
+    }
+
+    public void testGet_winSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDaimlerPeopleDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDefaultPeopleDetector() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetWinSigma() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptor() {
+        HOGDescriptor hog = new HOGDescriptor();
+
+        assertNotNull(hog);
+        assertEquals(HOGDescriptor.DEFAULT_NLEVELS, hog.get_nlevels());
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorSizeSizeSizeSizeIntIntDoubleIntDoubleBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testHOGDescriptorString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadString() {
+        fail("Not yet implemented");
+    }
+
+    public void testLoadStringString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSaveStringString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetSVMDetector() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/objdetect/ObjdetectTest.java b/modules/java/android_test/src/org/opencv/test/objdetect/ObjdetectTest.java
new file mode 100644
index 0000000000..64936872e0
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/objdetect/ObjdetectTest.java
@@ -0,0 +1,51 @@
+package org.opencv.test.objdetect;
+
+import java.util.ArrayList;
+
+import org.opencv.core.Rect;
+import org.opencv.objdetect.Objdetect;
+import org.opencv.test.OpenCVTestCase;
+
+public class ObjdetectTest extends OpenCVTestCase {
+
+    public void testGroupRectanglesListOfRectInt() {
+        Rect r = new Rect(10, 10, 20, 20);
+        ArrayList<Rect> rects = new ArrayList<Rect>();
+
+        for (int i = 0; i < 10; i++)
+            rects.add(r);
+
+        int groupThreshold = 1;
+        Objdetect.groupRectangles(rects, groupThreshold);
+        assertEquals(1, rects.size());
+    }
+
+    public void testGroupRectanglesListOfRectIntDouble() {
+        Rect r1 = new Rect(10, 10, 20, 20);
+        Rect r2 = new Rect(10, 10, 25, 25);
+        ArrayList<Rect> rects = new ArrayList<Rect>();
+
+        for (int i = 0; i < 10; i++)
+            rects.add(r1);
+        for (int i = 0; i < 10; i++)
+            rects.add(r2);
+
+        int groupThreshold = 1;
+        double eps = 0.2;
+        Objdetect.groupRectangles(rects, groupThreshold, eps);
+        assertEquals(2, rects.size());
+    }
+
+    public void testGroupRectanglesListOfRectIntDoubleListOfIntegerListOfDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testGroupRectanglesListOfRectListOfIntegerInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testGroupRectanglesListOfRectListOfIntegerIntDouble() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/utils/ConvertersTest.java b/modules/java/android_test/src/org/opencv/test/utils/ConvertersTest.java
new file mode 100644
index 0000000000..59c397c412
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/utils/ConvertersTest.java
@@ -0,0 +1,501 @@
+package org.opencv.test.utils;
+
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.core.Rect;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.utils.Converters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConvertersTest extends OpenCVTestCase {
+
+    public void testMat_to_vector_char() {
+        Mat src = new Mat(3, 1, CvType.CV_8SC1);
+        src.put(0, 0, 2, 4, 3);
+        List<Byte> bs = new ArrayList<Byte>();
+
+        Converters.Mat_to_vector_char(src, bs);
+
+        List<Byte> truth = new ArrayList<Byte>();
+        byte value1 = 2;
+        byte value2 = 4;
+        byte value3 = 3;
+        truth.add(new Byte(value1));
+        truth.add(new Byte(value2));
+        truth.add(new Byte(value3));
+        assertEquals(truth, bs);
+    }
+
+    public void testMat_to_vector_DMatch() {
+        Mat src = new Mat(4, 1, CvType.CV_64FC4);
+        src.put(0, 0, 1, 4, 4, 10, 2, 3, 5, 6, 3, 1, 8, 12, 4, 9, 5, 15);
+        List<DMatch> matches = new ArrayList<DMatch>();
+
+        Converters.Mat_to_vector_DMatch(src, matches);
+
+        List<DMatch> truth = new ArrayList<DMatch>();
+        truth.add(new DMatch(1, 4, 4, 10));
+        truth.add(new DMatch(2, 3, 5, 6));
+        truth.add(new DMatch(3, 1, 8, 12));
+        truth.add(new DMatch(4, 9, 5, 15));
+        assertListDMatchEquals(truth, matches, EPS);
+    }
+
+    public void testMat_to_vector_float() {
+        Mat src = new Mat(4, 1, CvType.CV_32FC1);
+        src.put(0, 0, 2, 4, 3, 9);
+        List<Float> fs = new ArrayList<Float>();
+
+        Converters.Mat_to_vector_float(src, fs);
+
+        List<Float> truth = new ArrayList<Float>();
+        truth.add(2.0f);
+        truth.add(4.0f);
+        truth.add(3.0f);
+        truth.add(9.0f);
+        assertListEquals(truth, fs, EPS);
+    }
+
+    public void testMat_to_vector_int() {
+        Mat src = new Mat(4, 1, CvType.CV_32SC1);
+        src.put(0, 0, 2, 4, 3, 9);
+        List<Integer> fs = new ArrayList<Integer>();
+
+        Converters.Mat_to_vector_int(src, fs);
+        List<Integer> truth = new ArrayList<Integer>();
+        truth.add(2);
+        truth.add(4);
+        truth.add(3);
+        truth.add(9);
+        assertListEquals(truth, fs);
+    }
+
+    public void testMat_to_vector_KeyPoint() {
+        Mat src = new Mat(1, 1, CvType.CV_64FC(7));
+        src.put(0, 0, 2, 4, 3, 9, 10, 12, 7);
+        List<KeyPoint> kps = new ArrayList<KeyPoint>();
+
+        Converters.Mat_to_vector_KeyPoint(src, kps);
+
+        List<KeyPoint> truth = new ArrayList<KeyPoint>();
+        truth.add(new KeyPoint(2, 4, 3, 9, 10, 12, 7));
+        assertListKeyPointEquals(truth, kps, EPS);
+    }
+
+    public void testMat_to_vector_Mat() {
+        // Mat src = new Mat(4, 1, CvType.CV_32SC2);
+        // src.put(0, 0, 2, 2, 3, 3, 4, 4, 5, 5);
+        //
+        // List<Mat> mats = new ArrayList<Mat>();
+        // Converters.Mat_to_vector_Mat(src, mats);
+        //
+        // List<Mat> truth = new ArrayList<Mat>();
+        // truth.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(2.0)));
+        // truth.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(3.0)));
+        // truth.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(4.0)));
+        // truth.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(5.0)));
+        // assertListEqualMat(truth, mats, EPS);
+        fail("Not yet implemented");
+    }
+
+    public void testMat_to_vector_Point() {
+        Mat src = new Mat(4, 1, CvType.CV_32SC2);
+        src.put(0, 0, 2, 4, 3, 9, 10, 4, 35, 54);
+        List<Point> points = new ArrayList<Point>();
+
+        Converters.Mat_to_vector_Point(src, points);
+
+        List<Point> truth = new ArrayList<Point>();
+        truth.add(new Point(2, 4));
+        truth.add(new Point(3, 9));
+        truth.add(new Point(10, 4));
+        truth.add(new Point(35, 54));
+        assertListPointEquals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point2d() {
+        Mat src = new Mat(4, 1, CvType.CV_64FC2);
+        src.put(0, 0, 12.0, 4.0, 3.0, 29.0, 10.0, 24.0, 35.0, 54.0);
+        List<Point> points = new ArrayList<Point>();
+
+        Converters.Mat_to_vector_Point2d(src, points);
+
+        List<Point> truth = new ArrayList<Point>();
+        truth.add(new Point(12.0, 4.0));
+        truth.add(new Point(3.0, 29.0));
+        truth.add(new Point(10.0, 24.0));
+        truth.add(new Point(35.0, 54.0));
+        assertListPointEquals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point2f() {
+        Mat src = new Mat(4, 1, CvType.CV_32FC2);
+        src.put(0, 0, 2, 14, 31, 19, 10, 44, 5, 41);
+        List<Point> points = new ArrayList<Point>();
+
+        Converters.Mat_to_vector_Point(src, points);
+
+        List<Point> truth = new ArrayList<Point>();
+        truth.add(new Point(2, 14));
+        truth.add(new Point(31, 19));
+        truth.add(new Point(10, 44));
+        truth.add(new Point(5, 41));
+        assertListPointEquals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point3() {
+        Mat src = new Mat(4, 1, CvType.CV_32SC3);
+        src.put(0, 0, 2, 14, 12, 31, 19, 22, 10, 44, 45, 5, 41, 31);
+        List<Point3> points = new ArrayList<Point3>();
+
+        Converters.Mat_to_vector_Point3(src, points);
+
+        List<Point3> truth = new ArrayList<Point3>();
+        truth.add(new Point3(2, 14, 12));
+        truth.add(new Point3(31, 19, 22));
+        truth.add(new Point3(10, 44, 45));
+        truth.add(new Point3(5, 41, 31));
+        assertListPoint3Equals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point3d() {
+        Mat src = new Mat(4, 1, CvType.CV_64FC3);
+        src.put(0, 0, 2.0, 4.0, 3.0, 5.0, 9.0, 12.0, 10.0, 14.0, 15.0, 5.0, 11.0, 31.0);
+        List<Point3> points = new ArrayList<Point3>();
+
+        Converters.Mat_to_vector_Point3(src, points);
+
+        List<Point3> truth = new ArrayList<Point3>();
+        truth.add(new Point3(2.0, 4.0, 3.0));
+        truth.add(new Point3(5.0, 9.0, 12.0));
+        truth.add(new Point3(10.0, 14.0, 15.0));
+        truth.add(new Point3(5.0, 11.0, 31.0));
+        assertListPoint3Equals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point3f() {
+        Mat src = new Mat(4, 1, CvType.CV_32FC3);
+        src.put(0, 0, 2.0, 4.0, 3.0, 5.0, 9.0, 12.0, 10.0, 14.0, 15.0, 5.0, 11.0, 31.0);
+        List<Point3> points = new ArrayList<Point3>();
+
+        Converters.Mat_to_vector_Point3(src, points);
+
+        List<Point3> truth = new ArrayList<Point3>();
+        truth.add(new Point3(2.0, 4.0, 3.0));
+        truth.add(new Point3(5.0, 9.0, 12.0));
+        truth.add(new Point3(10.0, 14.0, 15.0));
+        truth.add(new Point3(5.0, 11.0, 31.0));
+        assertListPoint3Equals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Point3i() {
+        Mat src = new Mat(4, 1, CvType.CV_32SC3);
+        src.put(0, 0, 2, 14, 12, 31, 19, 22, 10, 44, 45, 5, 41, 31);
+        List<Point3> points = new ArrayList<Point3>();
+
+        Converters.Mat_to_vector_Point3(src, points);
+
+        List<Point3> truth = new ArrayList<Point3>();
+        truth.add(new Point3(2, 14, 12));
+        truth.add(new Point3(31, 19, 22));
+        truth.add(new Point3(10, 44, 45));
+        truth.add(new Point3(5, 41, 31));
+        assertListPoint3Equals(truth, points, EPS);
+    }
+
+    public void testMat_to_vector_Rect() {
+        Mat src = new Mat(2, 1, CvType.CV_32SC4);
+        src.put(0, 0, 2, 2, 5, 2, 0, 0, 6, 4);
+        List<Rect> rectangles = new ArrayList<Rect>();
+
+        Converters.Mat_to_vector_Rect(src, rectangles);
+        List<Rect> truth = new ArrayList<Rect>();
+        truth.add(new Rect(2, 2, 5, 2));
+        truth.add(new Rect(0, 0, 6, 4));
+        assertListRectEquals(truth, rectangles);
+    }
+
+    public void testMat_to_vector_uchar() {
+        Mat src = new Mat(3, 1, CvType.CV_8UC1);
+        src.put(0, 0, 2, 4, 3);
+        List<Byte> bs = new ArrayList<Byte>();
+
+        Converters.Mat_to_vector_uchar(src, bs);
+
+        List<Byte> truth = new ArrayList<Byte>();
+        byte value1 = 2;
+        byte value2 = 4;
+        byte value3 = 3;
+        truth.add(new Byte(value1));
+        truth.add(new Byte(value2));
+        truth.add(new Byte(value3));
+        assertEquals(truth, bs);
+    }
+
+    public void testMat_to_vector_vector_char() {
+        fail("Not yet implemented");
+    }
+
+    public void testMat_to_vector_vector_DMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testMat_to_vector_vector_KeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testMat_to_vector_vector_Point2f() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_char_to_Mat() {
+        List<Byte> bytes = new ArrayList<Byte>();
+        byte value1 = 1;
+        byte value2 = 2;
+        byte value3 = 3;
+        byte value4 = 4;
+        bytes.add(new Byte(value1));
+        bytes.add(new Byte(value2));
+        bytes.add(new Byte(value3));
+        bytes.add(new Byte(value4));
+
+        dst = Converters.vector_char_to_Mat(bytes);
+        truth = new Mat(4, 1, CvType.CV_8SC1);
+        truth.put(0, 0, 1, 2, 3, 4);
+        assertMatEqual(truth, dst);
+
+    }
+
+    public void testVector_DMatch_to_Mat() {
+        List<DMatch> matches = new ArrayList<DMatch>();
+        matches.add(new DMatch(1, 4, 4, 10));
+        matches.add(new DMatch(2, 3, 5, 6));
+        matches.add(new DMatch(3, 1, 8, 12));
+        matches.add(new DMatch(4, 9, 5, 15));
+
+        dst = Converters.vector_DMatch_to_Mat(matches);
+
+        Mat truth = new Mat(4, 1, CvType.CV_64FC4);
+        truth.put(0, 0, 1, 4, 4, 10, 2, 3, 5, 6, 3, 1, 8, 12, 4, 9, 5, 15);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_double_to_Mat() {
+        List<Double> inputVector = new ArrayList<Double>();
+        inputVector.add(2.0);
+        inputVector.add(4.0);
+        inputVector.add(3.0);
+        inputVector.add(9.0);
+
+        dst = Converters.vector_double_to_Mat(inputVector);
+        truth = new Mat(4, 1, CvType.CV_64FC1);
+        truth.put(0, 0, 2, 4, 3, 9);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_float_to_Mat() {
+        List<Float> inputVector = new ArrayList<Float>();
+        inputVector.add(2.0f);
+        inputVector.add(4.0f);
+        inputVector.add(3.0f);
+        inputVector.add(9.0f);
+
+        dst = Converters.vector_float_to_Mat(inputVector);
+        truth = new Mat(4, 1, CvType.CV_32FC1);
+        truth.put(0, 0, 2, 4, 3, 9);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_int_to_Mat() {
+        List<Integer> inputVector = new ArrayList<Integer>();
+        inputVector.add(2);
+        inputVector.add(4);
+        inputVector.add(3);
+        inputVector.add(9);
+
+        dst = Converters.vector_int_to_Mat(inputVector);
+        truth = new Mat(4, 1, CvType.CV_32SC1);
+        truth.put(0, 0, 2, 4, 3, 9);
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_KeyPoint_to_Mat() {
+        List<KeyPoint> kps = new ArrayList<KeyPoint>();
+        kps.add(new KeyPoint(2, 4, 3, 9, 10, 12, 7));
+
+        dst = Converters.vector_KeyPoint_to_Mat(kps);
+
+        Mat truth = new Mat(1, 1, CvType.CV_64FC(7));
+        truth.put(0, 0, 2, 4, 3, 9, 10, 12, 7);
+
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_Mat_to_Mat() {
+        // List<Mat> mats = new ArrayList<Mat>();
+        // mats.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(2.0)));
+        // mats.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(2.0)));
+        // mats.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(2.0)));
+        // mats.add(new Mat(2, 1, CvType.CV_32SC1, Scalar.all(2.0)));
+        // mats.add(gray0);
+        // mats.add(gray255);
+        //
+        // dst = Converters.vector_Mat_to_Mat(mats);
+        fail("Not yet implemented");
+    }
+
+    public void testVector_Point_to_Mat() {
+        List<Point> points = new ArrayList<Point>();
+        points.add(new Point(2, 4));
+        points.add(new Point(3, 9));
+        points.add(new Point(10, 4));
+        points.add(new Point(35, 54));
+
+        dst = Converters.vector_Point_to_Mat(points);
+
+        truth = new Mat(4, 1, CvType.CV_32SC2);
+        truth.put(0, 0, 2, 4, 3, 9, 10, 4, 35, 54);
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_Point_to_MatListOfPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_Point_to_MatListOfPointInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_Point2d_to_Mat() {
+        List<Point> points = new ArrayList<Point>();
+        points.add(new Point(12.0, 4.0));
+        points.add(new Point(3.0, 9.0));
+        points.add(new Point(1.0, 2.0));
+
+        dst = Converters.vector_Point2d_to_Mat(points);
+
+        truth = new Mat(3, 1, CvType.CV_64FC2);
+        truth.put(0, 0, 12.0, 4.0, 3.0, 9.0, 1.0, 2.0);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_Point2f_to_Mat() {
+        List<Point> points = new ArrayList<Point>();
+        points.add(new Point(2.0, 3.0));
+        points.add(new Point(1.0, 2.0));
+        points.add(new Point(1.0, 4.0));
+
+        dst = Converters.vector_Point2f_to_Mat(points);
+
+        truth = new Mat(3, 1, CvType.CV_32FC2);
+        truth.put(0, 0, 2.0, 3.0, 1.0, 2.0, 1.0, 4.0);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_Point3_to_Mat() {
+        List<Point3> points = new ArrayList<Point3>();
+        points.add(new Point3(2, 4, 3));
+        points.add(new Point3(5, 9, 12));
+        points.add(new Point3(10, 14, 15));
+        points.add(new Point3(5, 11, 31));
+
+        dst = Converters.vector_Point3_to_Mat(points, CvType.CV_32S);
+        truth = new Mat(4, 1, CvType.CV_32SC3);
+        truth.put(0, 0, 2.0, 4.0, 3.0, 5.0, 9.0, 12.0, 10.0, 14.0, 15.0, 5.0, 11.0, 31.0);
+
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_Point3d_to_Mat() {
+        List<Point3> points = new ArrayList<Point3>();
+        points.add(new Point3(2.0, 4.0, 3.0));
+        points.add(new Point3(5.0, 9.0, 12.0));
+        points.add(new Point3(10.0, 14.0, 15.0));
+        points.add(new Point3(5.0, 11.0, 31.0));
+
+        dst = Converters.vector_Point3d_to_Mat(points);
+        truth = new Mat(4, 1, CvType.CV_64FC3);
+        truth.put(0, 0, 2.0, 4.0, 3.0, 5.0, 9.0, 12.0, 10.0, 14.0, 15.0, 5.0, 11.0, 31.0);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_Point3f_to_Mat() {
+        List<Point3> points = new ArrayList<Point3>();
+        points.add(new Point3(2.0, 4.0, 3.0));
+        points.add(new Point3(5.0, 9.0, 12.0));
+        points.add(new Point3(10.0, 14.0, 15.0));
+        points.add(new Point3(5.0, 11.0, 31.0));
+
+        dst = Converters.vector_Point3f_to_Mat(points);
+        truth = new Mat(4, 1, CvType.CV_32FC3);
+        truth.put(0, 0, 2.0, 4.0, 3.0, 5.0, 9.0, 12.0, 10.0, 14.0, 15.0, 5.0, 11.0, 31.0);
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testVector_Point3i_to_Mat() {
+        List<Point3> points = new ArrayList<Point3>();
+        points.add(new Point3(2, 4, 3));
+        points.add(new Point3(5, 6, 2));
+        points.add(new Point3(0, 4, 5));
+        points.add(new Point3(5, 1, 3));
+
+        dst = Converters.vector_Point3i_to_Mat(points);
+
+        truth = new Mat(4, 1, CvType.CV_32SC3);
+        truth.put(0, 0, 2, 4, 3, 5, 6, 2, 0, 4, 5, 5, 1, 3);
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_Rect_to_Mat() {
+        List<Rect> rectangles = new ArrayList<Rect>();
+        rectangles.add(new Rect(2, 2, 5, 2));
+        rectangles.add(new Rect(0, 0, 6, 4));
+
+        dst = Converters.vector_Rect_to_Mat(rectangles);
+
+        truth = new Mat(2, 1, CvType.CV_32SC4);
+        truth.put(0, 0, 2, 2, 5, 2, 0, 0, 6, 4);
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_uchar_to_Mat() {
+        List<Byte> bytes = new ArrayList<Byte>();
+        byte value1 = 1;
+        byte value2 = 2;
+        byte value3 = 3;
+        byte value4 = 4;
+        bytes.add(new Byte(value1));
+        bytes.add(new Byte(value2));
+        bytes.add(new Byte(value3));
+        bytes.add(new Byte(value4));
+
+        dst = Converters.vector_uchar_to_Mat(bytes);
+        truth = new Mat(4, 1, CvType.CV_8UC1);
+        truth.put(0, 0, 1, 2, 3, 4);
+        assertMatEqual(truth, dst);
+    }
+
+    public void testVector_vector_char_to_Mat() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_vector_DMatch_to_Mat() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_vector_KeyPoint_to_Mat() {
+        fail("Not yet implemented");
+    }
+
+    public void testVector_vector_Point_to_Mat() {
+        fail("Not yet implemented");
+
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/video/BackgroundSubtractorMOGTest.java b/modules/java/android_test/src/org/opencv/test/video/BackgroundSubtractorMOGTest.java
new file mode 100644
index 0000000000..c6fa4dec76
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/video/BackgroundSubtractorMOGTest.java
@@ -0,0 +1,51 @@
+package org.opencv.test.video;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.Highgui;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.video.BackgroundSubtractorMOG;
+
+public class BackgroundSubtractorMOGTest extends OpenCVTestCase {
+
+    public void testApplyMatMat() {
+        fail("Not yet implemented");
+        BackgroundSubtractorMOG backGroundSubtract = new BackgroundSubtractorMOG();
+
+        Point bottomRight = new Point(rgbLena.cols() / 2, rgbLena.rows() / 2);
+        Point topLeft = new Point(0, 0);
+        Scalar color = new Scalar(128);
+        Mat mask = new Mat(rgbLena.size(), CvType.CV_16UC3, new Scalar(1));
+
+        Core.rectangle(rgbLena, bottomRight, topLeft, color, Core.FILLED);
+
+        backGroundSubtract.apply(rgbLena, mask);
+
+        Mat truth = new Mat(rgbLena.size(), rgbLena.type(), new Scalar(0));
+        Core.rectangle(truth, bottomRight, topLeft, color, Core.FILLED);
+        // OpenCVTestRunner.Log(dst.dump());
+        // OpenCVTestRunner.Log(rgbLena.dump());
+        Highgui.imwrite("/mnt/sdcard/lena1.png", rgbLena);
+        assertMatEqual(truth, rgbLena);
+    }
+
+    public void testApplyMatMatDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testBackgroundSubtractorMOG() {
+        fail("Not yet implemented");
+    }
+
+    public void testBackgroundSubtractorMOGIntIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testBackgroundSubtractorMOGIntIntDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/video/KalmanFilterTest.java b/modules/java/android_test/src/org/opencv/test/video/KalmanFilterTest.java
new file mode 100644
index 0000000000..db35a8d35f
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/video/KalmanFilterTest.java
@@ -0,0 +1,38 @@
+package org.opencv.test.video;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.video.KalmanFilter;
+
+public class KalmanFilterTest extends OpenCVTestCase {
+
+    public void testCorrect() {
+        fail("Not yet implemented");
+    }
+
+    public void testKalmanFilter() {
+        KalmanFilter kf = new KalmanFilter();
+
+        assertNotNull(kf);
+    }
+
+    public void testKalmanFilterIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKalmanFilterIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKalmanFilterIntIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredict() {
+        fail("Not yet implemented");
+    }
+
+    public void testPredictMat() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/android_test/src/org/opencv/test/video/VideoTest.java b/modules/java/android_test/src/org/opencv/test/video/VideoTest.java
new file mode 100644
index 0000000000..beccccfa19
--- /dev/null
+++ b/modules/java/android_test/src/org/opencv/test/video/VideoTest.java
@@ -0,0 +1,118 @@
+package org.opencv.test.video;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.utils.Converters;
+import org.opencv.video.Video;
+
+public class VideoTest extends OpenCVTestCase {
+
+    private List<Float> err = null;
+    private int h;
+    private List<Point> nextPts = null;
+    List<Point> prevPts = null;
+
+    private int shift1;
+    private int shift2;
+
+    private List<Byte> status = null;
+    private Mat subLena1 = null;
+    private Mat subLena2 = null;
+    private int w;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        shift1 = 10;
+        shift2 = 17;
+        w = (int)(rgbLena.cols() / 2);
+        h = (int)(rgbLena.rows() / 2);
+
+        subLena1 = rgbLena.submat(shift1, h + shift1, shift1, w + shift1);
+        subLena2 = rgbLena.submat(shift2, h + shift2, shift2, w + shift2);
+
+        prevPts = new ArrayList<Point>();
+        prevPts.add(new Point(1.0, 1.0));
+        prevPts.add(new Point(5.0, 5.0));
+        prevPts.add(new Point(10.0, 10.0));
+
+        nextPts = new ArrayList<Point>();
+        status = new ArrayList<Byte>();
+        err = new ArrayList<Float>();
+    }
+
+    public void testCalcGlobalOrientation() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcMotionGradientMatMatMatDoubleDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcMotionGradientMatMatMatDoubleDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowFarneback() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloat() {
+        Video.calcOpticalFlowPyrLK(subLena1, subLena2, prevPts, nextPts, status, err);
+        assertEquals(3, Core.countNonZero(Converters.vector_uchar_to_Mat(status)));
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSize() {
+        Size sz = new Size(3, 3);
+        Video.calcOpticalFlowPyrLK(subLena1, subLena2, prevPts, nextPts, status, err, sz);
+        assertEquals(0, Core.countNonZero(Converters.vector_uchar_to_Mat(status)));
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSizeInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSizeIntTermCriteria() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSizeIntTermCriteriaDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSizeIntTermCriteriaDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testCalcOpticalFlowPyrLKMatMatListOfPointListOfPointListOfByteListOfFloatSizeIntTermCriteriaDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testCamShift() {
+        fail("Not yet implemented");
+    }
+
+    public void testEstimateRigidTransform() {
+        fail("Not yet implemented");
+    }
+
+    public void testMeanShift() {
+        fail("Not yet implemented");
+    }
+
+    public void testSegmentMotion() {
+        fail("Not yet implemented");
+    }
+
+    public void testUpdateMotionHistory() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/modules/java/check-tests.py b/modules/java/check-tests.py
new file mode 100644
index 0000000000..f2a2673add
--- /dev/null
+++ b/modules/java/check-tests.py
@@ -0,0 +1,163 @@
+import sys, os, re
+
+classes_ignore_list = (
+    'OpenCV(Test)?Case',
+    'OpenCV(Test)?Runner',
+    'CvException',
+)
+
+funcs_ignore_list = (
+    '\w+--HashCode',
+    'Mat--MatLong',
+    '\w+--Equals',
+    'Core--MinMaxLocResult',
+)
+
+class JavaParser:
+    def __init__(self):
+        self.clear()
+
+    def clear(self):
+        self.mdict = {}
+        self.tdict = {}
+        self.mwhere = {}
+        self.twhere = {}
+        self.empty_stubs_cnt = 0
+        self.r1 = re.compile("\s*public\s+(?:static\s+)?(\w+)\(([^)]*)\)") # c-tor
+        self.r2 = re.compile("\s*(?:(?:public|static|final)\s+){1,3}\S+\s+(\w+)\(([^)]*)\)")
+        self.r3 = re.compile('\s*fail\("Not yet implemented"\);') # empty test stub
+
+
+    def dict2set(self, d):
+        s = set()
+        for f in d.keys():
+            if len(d[f]) == 1:
+                s.add(f)
+            else:
+                s |= set(d[f])
+        return s
+
+
+    def get_tests_count(self):
+        return len(self.tdict)
+
+    def get_empty_stubs_count(self):
+        return self.empty_stubs_cnt
+
+    def get_funcs_count(self):
+        return len(self.dict2set(self.mdict)), len(self.mdict)
+
+    def get_not_tested(self):
+        mset = self.dict2set(self.mdict)
+        tset = self.dict2set(self.tdict)
+        nottested = mset - tset
+        out = set()
+
+        for name in nottested:
+            out.add(name + "   " + self.mwhere[name])
+
+        return out
+
+
+    def parse(self, path):
+        if ".svn" in path:
+            return
+        if os.path.isfile(path):
+            if path.endswith("FeatureDetector.java"):
+                for prefix1 in ("", "Grid", "Pyramid", "Dynamic"):
+                    for prefix2 in ("FAST", "STAR", "MSER", "ORB", "SIFT", "SURF", "GFTT", "HARRIS", "SIMPLEBLOB", "DENSE"):
+                        parser.parse_file(path,prefix1+prefix2)
+            elif path.endswith("DescriptorExtractor.java"):
+                for prefix1 in ("", "Opponent"):
+                    for prefix2 in ("BRIEF", "ORB", "SIFT", "SURF"):
+                        parser.parse_file(path,prefix1+prefix2)
+            elif path.endswith("GenericDescriptorMatcher.java"):
+                for prefix in ("OneWay", "Fern"):
+                    parser.parse_file(path,prefix)
+            elif path.endswith("DescriptorMatcher.java"):
+                for prefix in ("BruteForce", "BruteForceHamming", "BruteForceHammingLUT", "BruteForceL1", "FlannBased", "BruteForceSL2"):
+                    parser.parse_file(path,prefix)
+            else:
+                parser.parse_file(path)
+        elif os.path.isdir(path):
+            for x in os.listdir(path):
+                self.parse(path + "/" + x)
+        return
+
+
+    def parse_file(self, fname, prefix = ""):
+        istest = fname.endswith("Test.java")
+        clsname = os.path.basename(fname).replace("Test", "").replace(".java", "")
+        clsname = prefix + clsname[0].upper() + clsname[1:]
+        for cls in classes_ignore_list:
+            if re.match(cls, clsname):
+                return
+        f = open(fname, "rt")
+        linenum = 0
+        for line in f:
+            linenum += 1
+            m1 = self.r1.match(line)
+            m2 = self.r2.match(line)
+            m3 = self.r3.match(line)
+            func = ''
+            args_str = ''
+            if m1:
+                func = m1.group(1)
+                args_str = m1.group(2)
+            elif m2:
+                if "public" not in line:
+                    continue
+                func = m2.group(1)
+                args_str = m2.group(2)
+            elif m3:
+                self.empty_stubs_cnt += 1
+                continue
+            else:
+                #if "public" in line:
+                    #print "UNRECOGNIZED: " + line
+                continue
+            d = (self.mdict, self.tdict)[istest]
+            w = (self.mwhere, self.twhere)[istest]
+            func = re.sub(r"^test", "", func)
+            func = clsname + "--" + func[0].upper() + func[1:]
+            args_str = args_str.replace("[]", "Array").replace("...", "Array ")
+            args_str = re.sub(r"List<(\w+)>", "ListOf\g<1>", args_str)
+            args_str = re.sub(r"List<(\w+)>", "ListOf\g<1>", args_str)
+            args = [a.split()[0] for a in args_str.split(",") if a]
+            func_ex = func + "".join([a[0].upper() + a[1:] for a in args])
+            func_loc = fname + " (line: " + str(linenum)  + ")"
+            skip = False
+            for fi in funcs_ignore_list:
+                if re.match(fi, func_ex):
+                    skip = True
+                    break
+            if skip:
+                continue
+            if func in d:
+                d[func].append(func_ex)
+            else:
+                d[func] = [func_ex]
+            w[func_ex] = func_loc
+            w[func] = func_loc
+
+        f.close()
+        return
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print "Usage:\n", \
+            os.path.basename(sys.argv[0]), \
+            "<Classes/Tests dir1/file1> [<Classes/Tests dir2/file2> ...]\n", "Not tested methods are loggedto stdout."
+        exit(0)
+    parser = JavaParser()
+    for x in sys.argv[1:]:
+        parser.parse(x)
+    funcs = parser.get_not_tested()
+    if funcs:
+        print "NOT TESTED methods:\n\t", "\n\t".join(sorted(funcs))
+    print "Total methods found: %i (%i)" % parser.get_funcs_count()
+    print "Not tested methods found:", len(funcs)
+    print "Total tests found:", parser.get_tests_count()
+    print "Empty test stubs found:", parser.get_empty_stubs_count()
+
diff --git a/modules/java/config/core.filelist b/modules/java/config/core.filelist
new file mode 100644
index 0000000000..76d6dd91ba
--- /dev/null
+++ b/modules/java/config/core.filelist
@@ -0,0 +1 @@
+include/opencv2/core/core.hpp
diff --git a/modules/java/config/features2d.filelist b/modules/java/config/features2d.filelist
new file mode 100644
index 0000000000..cbe849e6ce
--- /dev/null
+++ b/modules/java/config/features2d.filelist
@@ -0,0 +1,2 @@
+include/opencv2/features2d/features2d.hpp
+../java/src/cpp/features2d_manual.hpp
diff --git a/modules/java/gen_java.py b/modules/java/gen_java.py
new file mode 100644
index 0000000000..562499a826
--- /dev/null
+++ b/modules/java/gen_java.py
@@ -0,0 +1,1484 @@
+import sys, re, os.path
+from string import Template
+
+try:
+    from cStringIO import StringIO
+except:
+    from StringIO import StringIO
+
+class_ignore_list = (
+    #core
+    "FileNode", "FileStorage", "KDTree",
+    #highgui
+    "VideoWriter", "VideoCapture",
+    #features2d
+    "KeyPoint", "MSER", "StarDetector", "SURF",
+)
+
+const_ignore_list = (
+    "CV_CAP_OPENNI",
+    "CV_CAP_PROP_OPENNI_",
+    "WINDOW_AUTOSIZE",
+    "CV_WND_PROP_",
+    "CV_WINDOW_",
+    "CV_EVENT_",
+    "CV_GUI_",
+    "CV_PUSH_BUTTON",
+    "CV_CHECKBOX",
+    "CV_RADIOBOX",
+
+    #attention!
+    #the following constants are added to this list using code automatic generation
+    #TODO: should be checked
+    "CV_CAP_ANY",
+    "CV_CAP_MIL",
+    "CV_CAP_VFW",
+    "CV_CAP_V4L",
+    "CV_CAP_V4L2",
+    "CV_CAP_FIREWARE",
+    "CV_CAP_FIREWIRE",
+    "CV_CAP_IEEE1394",
+    "CV_CAP_DC1394",
+    "CV_CAP_CMU1394",
+    "CV_CAP_STEREO",
+    "CV_CAP_TYZX",
+    "CV_TYZX_LEFT",
+    "CV_TYZX_RIGHT",
+    "CV_TYZX_COLOR",
+    "CV_TYZX_Z",
+    "CV_CAP_QT",
+    "CV_CAP_UNICAP",
+    "CV_CAP_DSHOW",
+    "CV_CAP_PVAPI",
+    "CV_CAP_PROP_DC1394_OFF",
+    "CV_CAP_PROP_DC1394_MODE_MANUAL",
+    "CV_CAP_PROP_DC1394_MODE_AUTO",
+    "CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO",
+    "CV_CAP_PROP_POS_MSEC",
+    "CV_CAP_PROP_POS_FRAMES",
+    "CV_CAP_PROP_POS_AVI_RATIO",
+    "CV_CAP_PROP_FPS",
+    "CV_CAP_PROP_FOURCC",
+    "CV_CAP_PROP_FRAME_COUNT",
+    "CV_CAP_PROP_FORMAT",
+    "CV_CAP_PROP_MODE",
+    "CV_CAP_PROP_BRIGHTNESS",
+    "CV_CAP_PROP_CONTRAST",
+    "CV_CAP_PROP_SATURATION",
+    "CV_CAP_PROP_HUE",
+    "CV_CAP_PROP_GAIN",
+    "CV_CAP_PROP_EXPOSURE",
+    "CV_CAP_PROP_CONVERT_RGB",
+    "CV_CAP_PROP_WHITE_BALANCE_BLUE_U",
+    "CV_CAP_PROP_RECTIFICATION",
+    "CV_CAP_PROP_MONOCROME",
+    "CV_CAP_PROP_SHARPNESS",
+    "CV_CAP_PROP_AUTO_EXPOSURE",
+    "CV_CAP_PROP_GAMMA",
+    "CV_CAP_PROP_TEMPERATURE",
+    "CV_CAP_PROP_TRIGGER",
+    "CV_CAP_PROP_TRIGGER_DELAY",
+    "CV_CAP_PROP_WHITE_BALANCE_RED_V",
+    "CV_CAP_PROP_MAX_DC1394",
+    "CV_CAP_GSTREAMER_QUEUE_LENGTH",
+    "CV_CAP_PROP_PVAPI_MULTICASTIP",
+    "CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING",
+    "EVENT_.*",
+    "CV_L?(BGRA?|RGBA?|GRAY|XYZ|YCrCb|Luv|Lab|HLS|YUV|HSV)\d*2L?(BGRA?|RGBA?|GRAY|XYZ|YCrCb|Luv|Lab|HLS|YUV|HSV).*",
+    "CV_COLORCVT_MAX",
+    "CV_.*Bayer.*",
+    "CV_YUV420(i|sp)2.+",
+    "CV_TM_.+",
+    "CV_FLOODFILL_.+",
+    "CV_ADAPTIVE_THRESH_.+",
+)
+
+const_private_list = (
+    "CV_MOP_.+",
+    "CV_INTER_.+",
+    "CV_THRESH_.+",
+    "CV_INPAINT_.+",
+    "CV_RETR_.+",
+    "CV_CHAIN_APPROX_.+",
+    "OPPONENTEXTRACTOR",
+    "GRIDRETECTOR",
+    "PYRAMIDDETECTOR",
+    "DYNAMICDETECTOR",
+)
+
+# { Module : { public : [[name, val],...], private : [[]...] } }
+missing_consts = \
+{
+    'Core' :
+    {
+        'private' :
+        (
+            ('CV_8U',  0 ), ('CV_8S',  1 ),
+            ('CV_16U', 2 ), ('CV_16S', 3 ),
+            ('CV_32S', 4 ),
+            ('CV_32F', 5 ), ('CV_64F', 6 ),
+            ('CV_USRTYPE1', 7 ),
+        ), # private
+        'public' :
+        (
+            ('SVD_MODIFY_A', 1), ('SVD_NO_UV', 2), ('SVD_FULL_UV', 4), 
+            ('FILLED', -1),
+            ('LINE_AA', 16), ('LINE_8', 8), ('LINE_4', 4),
+            ('REDUCE_SUM', 0), ('REDUCE_AVG', 1), ('REDUCE_MAX', 2), ('REDUCE_MIN', 3),
+        ) #public
+    }, # Core
+
+    "Imgproc":
+    {
+        'private' :
+        (
+            ('IPL_BORDER_CONSTANT',    0 ),
+            ('IPL_BORDER_REPLICATE',   1 ),
+            ('IPL_BORDER_REFLECT',     2 ),
+            ('IPL_BORDER_WRAP',        3 ),
+            ('IPL_BORDER_REFLECT_101', 4 ),
+            ('IPL_BORDER_TRANSPARENT', 5 ),
+        ) # private
+    }, # Imgproc
+
+    "Calib3d":
+    {
+        'private' :
+        (
+            ('CV_LMEDS',  4),
+            ('CV_RANSAC', 8),
+            ('CV_FM_LMEDS', 'CV_LMEDS'),
+            ('CV_FM_RANSAC','CV_RANSAC'),
+            ('CV_FM_7POINT', 1),
+            ('CV_FM_8POINT', 2),
+            ('CV_CALIB_USE_INTRINSIC_GUESS', 1),
+            ('CV_CALIB_FIX_ASPECT_RATIO',    2),
+            ('CV_CALIB_FIX_PRINCIPAL_POINT', 4),
+            ('CV_CALIB_ZERO_TANGENT_DIST',   8),
+            ('CV_CALIB_FIX_FOCAL_LENGTH',   16),
+            ('CV_CALIB_FIX_K1',             32),
+            ('CV_CALIB_FIX_K2',             64),
+            ('CV_CALIB_FIX_K3',            128),
+            ('CV_CALIB_FIX_K4',           2048),
+            ('CV_CALIB_FIX_K5',           4096),
+            ('CV_CALIB_FIX_K6',           8192),
+            ('CV_CALIB_RATIONAL_MODEL',  16384),
+            ('CV_CALIB_FIX_INTRINSIC',     256),
+            ('CV_CALIB_SAME_FOCAL_LENGTH', 512),
+            ('CV_CALIB_ZERO_DISPARITY',   1024),
+        ) # public
+    }, # Calib3d
+
+}
+
+
+# c_type    : { java/jni correspondence }
+type_dict = {
+# "simple"  : { j_type : "?", jn_type : "?", jni_type : "?", suffix : "?" },
+    ""        : { "j_type" : "", "jn_type" : "long", "jni_type" : "jlong" }, # c-tor ret_type
+    "void"    : { "j_type" : "void", "jn_type" : "void", "jni_type" : "void" },
+    "env"     : { "j_type" : "", "jn_type" : "", "jni_type" : "JNIEnv*"},
+    "cls"     : { "j_type" : "", "jn_type" : "", "jni_type" : "jclass"},
+    "bool"    : { "j_type" : "boolean", "jn_type" : "boolean", "jni_type" : "jboolean", "suffix" : "Z" },
+    "int"     : { "j_type" : "int", "jn_type" : "int", "jni_type" : "jint", "suffix" : "I" },
+    "long"    : { "j_type" : "int", "jn_type" : "int", "jni_type" : "jint", "suffix" : "I" },
+    "float"   : { "j_type" : "float", "jn_type" : "float", "jni_type" : "jfloat", "suffix" : "F" },
+    "double"  : { "j_type" : "double", "jn_type" : "double", "jni_type" : "jdouble", "suffix" : "D" },
+    "size_t"  : { "j_type" : "long", "jn_type" : "long", "jni_type" : "jlong", "suffix" : "J" },
+    "__int64" : { "j_type" : "long", "jn_type" : "long", "jni_type" : "jlong", "suffix" : "J" },
+    "int64"   : { "j_type" : "long", "jn_type" : "long", "jni_type" : "jlong", "suffix" : "J" },
+    "double[]": { "j_type" : "double[]", "jn_type" : "double[]", "jni_type" : "jdoubleArray", "suffix" : "_3D" },
+
+# "complex" : { j_type : "?", jn_args : (("", ""),), jn_name : "", jni_var : "", jni_name : "", "suffix" : "?" },
+
+    "vector_Point"    : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point> %(n)s", "suffix" : "J" },
+    "vector_Point2f"  : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2f> %(n)s", "suffix" : "J" },
+    "vector_Point2d"  : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2d> %(n)s", "suffix" : "J" },
+    "vector_Point3i"  : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3i> %(n)s", "suffix" : "J" },
+    "vector_Point3f"  : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3f> %(n)s", "suffix" : "J" },
+    "vector_Point3d"  : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3d> %(n)s", "suffix" : "J" },
+    "vector_Mat"      : { "j_type" : "List<Mat>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Mat> %(n)s", "suffix" : "J" },
+    "vector_KeyPoint" : { "j_type" : "List<KeyPoint>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<KeyPoint> %(n)s", "suffix" : "J" },
+    "vector_DMatch"   : { "j_type" : "List<DMatch>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<DMatch> %(n)s", "suffix" : "J" },
+    "vector_Rect"     : { "j_type" : "List<Rect>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Rect> %(n)s", "suffix" : "J" },
+    "vector_uchar"    : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<uchar> %(n)s", "suffix" : "J" },
+    "vector_char"     : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<char> %(n)s", "suffix" : "J" },
+    "vector_int"      : { "j_type" : "List<Integer>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<int> %(n)s", "suffix" : "J" },
+    "vector_float"    : { "j_type" : "List<Float>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<float> %(n)s", "suffix" : "J" },
+    "vector_double"   : { "j_type" : "List<Double>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<double> %(n)s", "suffix" : "J" },
+    "vector_Vec4f"    : { "j_type" : "Mat", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec4f> %(n)s", "suffix" : "J" },
+    "vector_Vec6f"    : { "j_type" : "Mat", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec6f> %(n)s", "suffix" : "J" },
+
+    "vector_vector_KeyPoint": { "j_type" : "List<List<KeyPoint>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<KeyPoint> > %(n)s" },
+    "vector_vector_DMatch"  : { "j_type" : "List<List<DMatch>>",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<DMatch> > %(n)s" },
+    "vector_vector_char"    : { "j_type" : "List<List<Byte>>",     "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<char> > %(n)s" },
+    "vector_vector_Point"   : { "j_type" : "List<List<Point>>",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point> > %(n)s" },
+    "vector_vector_Point2f" : { "j_type" : "List<List<Point>>",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point2f> > %(n)s" },
+
+    "Mat"     : { "j_type" : "Mat", "jn_type" : "long", "jn_args" : (("__int64", ".nativeObj"),),
+                  "jni_var" : "Mat& %(n)s = *((Mat*)%(n)s_nativeObj)",
+                  "jni_type" : "jlong", #"jni_name" : "*%(n)s",
+                  "suffix" : "J" },
+    "Point"   : { "j_type" : "Point", "jn_args" : (("double", ".x"), ("double", ".y")),
+                  "jni_var" : "Point %(n)s((int)%(n)s_x, (int)%(n)s_y)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DD"},
+    "Point2f" : { "j_type" : "Point", "jn_args" : (("double", ".x"), ("double", ".y")),
+                  "jni_var" : "Point2f %(n)s((float)%(n)s_x, (float)%(n)s_y)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DD"},
+    "Point2d" : { "j_type" : "Point", "jn_args" : (("double", ".x"), ("double", ".y")),
+                  "jni_var" : "Point2d %(n)s(%(n)s_x, %(n)s_y)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DD"},
+    "Point3i" : { "j_type" : "Point3", "jn_args" : (("double", ".x"), ("double", ".y"), ("double", ".z")),
+                  "jni_var" : "Point3i %(n)s((int)%(n)s_x, (int)%(n)s_y, (int)%(n)s_z)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DDD"},
+    "Point3f" : { "j_type" : "Point3", "jn_args" : (("double", ".x"), ("double", ".y"), ("double", ".z")),
+                  "jni_var" : "Point3f %(n)s((float)%(n)s_x, (float)%(n)s_y, (float)%(n)s_z)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DDD"},
+    "Point3d" : { "j_type" : "Point3", "jn_args" : (("double", ".x"), ("double", ".y"), ("double", ".z")),
+                  "jni_var" : "Point3d %(n)s(%(n)s_x, %(n)s_y, %(n)s_z)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DDD"},
+    "KeyPoint": { "j_type" : "KeyPoint", "jn_args" : (("float", ".x"), ("float", ".y"), ("float", ".size"),
+                    ("float", ".angle"), ("float", ".response"), ("int", ".octave"), ("int", ".class_id")),
+                  "jni_var" : "KeyPoint %(n)s(%(n)s_x, %(n)s_y, %(n)s_size, %(n)s_angle, %(n)s_response, %(n)s_octave, %(n)s_class_id)",
+                  "jni_type" : "jdoubleArray",
+                  "suffix" : "FFFFFII"},
+    "DMatch" :  { "j_type" : "DMatch", "jn_args" : ( ('int', 'queryIdx'), ('int', 'trainIdx'),
+                    ('int', 'imgIdx'), ('float', 'distance'), ),
+                  "jni_var" : "DMatch %(n)s(%(n)s_queryIdx, %(n)s_trainIdx, %(n)s_imgIdx, %(n)s_distance)",
+                  "jni_type" : "jdoubleArray",
+                  "suffix" : "IIIF"},
+    "Rect"    : { "j_type" : "Rect",  "jn_args" : (("int", ".x"), ("int", ".y"), ("int", ".width"), ("int", ".height")),
+                  "jni_var" : "Rect %(n)s(%(n)s_x, %(n)s_y, %(n)s_width, %(n)s_height)", "jni_type" : "jdoubleArray",
+                  "suffix" : "IIII"},
+    "Size"    : { "j_type" : "Size",  "jn_args" : (("double", ".width"), ("double", ".height")),
+                  "jni_var" : "Size %(n)s((int)%(n)s_width, (int)%(n)s_height)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DD"},
+    "Size2f"  : { "j_type" : "Size",  "jn_args" : (("double", ".width"), ("double", ".height")),
+                  "jni_var" : "Size2f %(n)s((float)%(n)s_width, (float)%(n)s_height)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DD"},
+ "RotatedRect": { "j_type" : "RotatedRect",  "jn_args" : (("double", ".center.x"), ("double", ".center.y"), ("double", ".size.width"), ("double", ".size.height"), ("double", ".angle")),
+                  "jni_var" : "RotatedRect %(n)s(cv::Point2f(%(n)s_center_x, %(n)s_center_y), cv::Size2f(%(n)s_size_width, %(n)s_size_height), %(n)s_angle)",
+                  "jni_type" : "jdoubleArray", "suffix" : "DDDDD"},
+    "Scalar"  : { "j_type" : "Scalar",  "jn_args" : (("double", ".val[0]"), ("double", ".val[1]"), ("double", ".val[2]"), ("double", ".val[3]")),
+                  "jni_var" : "Scalar %(n)s(%(n)s_val0, %(n)s_val1, %(n)s_val2, %(n)s_val3)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DDDD"},
+    "Range"   : { "j_type" : "Range",  "jn_args" : (("int", ".start"), ("int", ".end")),
+                  "jni_var" : "Range %(n)s(%(n)s_start, %(n)s_end)", "jni_type" : "jdoubleArray",
+                  "suffix" : "II"},
+    "CvSlice" : { "j_type" : "Range",  "jn_args" : (("int", ".start"), ("int", ".end")),
+                  "jni_var" : "Range %(n)s(%(n)s_start, %(n)s_end)", "jni_type" : "jdoubleArray",
+                  "suffix" : "II"},
+    "string"  : { "j_type" : "String",  "jn_type" : "String",
+                  "jni_type" : "jstring", "jni_name" : "n_%(n)s",
+                  "jni_var" : 'const char* utf_%(n)s = env->GetStringUTFChars(%(n)s, 0); std::string n_%(n)s( utf_%(n)s ? utf_%(n)s : "" ); env->ReleaseStringUTFChars(%(n)s, utf_%(n)s)',
+                  "suffix" : "Ljava_lang_String_2"},
+    "String"  : { "j_type" : "String",  "jn_type" : "String",
+                  "jni_type" : "jstring", "jni_name" : "n_%(n)s",
+                  "jni_var" : 'const char* utf_%(n)s = env->GetStringUTFChars(%(n)s, 0); String n_%(n)s( utf_%(n)s ? utf_%(n)s : "" ); env->ReleaseStringUTFChars(%(n)s, utf_%(n)s)',
+                  "suffix" : "Ljava_lang_String_2"},
+    "c_string": { "j_type" : "String",  "jn_type" : "String",
+                  "jni_type" : "jstring", "jni_name" : "n_%(n)s.c_str()",
+                  "jni_var" : 'const char* utf_%(n)s = env->GetStringUTFChars(%(n)s, 0); std::string n_%(n)s( utf_%(n)s ? utf_%(n)s : "" ); env->ReleaseStringUTFChars(%(n)s, utf_%(n)s)',
+                  "suffix" : "Ljava_lang_String_2"},
+"TermCriteria": { "j_type" : "TermCriteria",  "jn_args" : (("int", ".type"), ("int", ".maxCount"), ("double", ".epsilon")),
+                  "jni_var" : "TermCriteria %(n)s(%(n)s_type, %(n)s_maxCount, %(n)s_epsilon)",
+                  "suffix" : "IID"},
+    "Vec3d"   : { "j_type" : "double[]",  "jn_args" : (("double", ".val[0]"), ("double", ".val[1]"), ("double", ".val[2]")),
+                  "jn_type" : "double[]",
+                  "jni_var" : "Vec3d %(n)s(%(n)s_val0, %(n)s_val1, %(n)s_val2)", "jni_type" : "jdoubleArray",
+                  "suffix" : "DDD"},
+
+}
+
+# { class : { func : {j_code, jn_code, cpp_code} } }
+ManualFuncs = {
+    'Core' :
+    {
+        'minMaxLoc' : {
+            'j_code'   : """
+    // manual port
+    public static class MinMaxLocResult {
+        public double minVal;
+        public double maxVal;
+        public Point minLoc;
+        public Point maxLoc;
+
+    	public MinMaxLocResult() {
+    	    minVal=0; maxVal=0;
+    	    minLoc=new Point();
+    	    maxLoc=new Point();
+    	}
+    }
+
+    // C++: minMaxLoc(Mat src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
+
+    //javadoc: minMaxLoc(src, mask)
+    public static MinMaxLocResult minMaxLoc(Mat src, Mat mask) {
+        MinMaxLocResult res = new MinMaxLocResult();
+        long maskNativeObj=0;
+        if (mask != null) {
+            maskNativeObj=mask.nativeObj;
+        }
+        double resarr[] = n_minMaxLocManual(src.nativeObj, maskNativeObj);
+        res.minVal=resarr[0];
+        res.maxVal=resarr[1];
+        res.minLoc.x=resarr[2];
+        res.minLoc.y=resarr[3];
+        res.maxLoc.x=resarr[4];
+        res.maxLoc.y=resarr[5];
+        return res;
+    }
+
+    //javadoc: minMaxLoc(src)
+    public static MinMaxLocResult minMaxLoc(Mat src) {
+        return minMaxLoc(src, null);
+    }
+
+""",
+            'jn_code'  :
+"""    private static native double[] n_minMaxLocManual(long src_nativeObj, long mask_nativeObj);\n""",
+            'cpp_code' :
+"""
+// C++: minMaxLoc(Mat src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray())
+
+JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Core_n_1minMaxLocManual
+  (JNIEnv* env, jclass cls, jlong src_nativeObj, jlong mask_nativeObj)
+{
+    try {
+        LOGD("Core::n_1minMaxLoc()");
+        jdoubleArray result;
+        result = env->NewDoubleArray(6);
+        if (result == NULL) {
+            return NULL; /* out of memory error thrown */
+        }
+
+        Mat& src = *((Mat*)src_nativeObj);
+
+        double minVal, maxVal;
+        Point minLoc, maxLoc;
+        if (mask_nativeObj != 0) {
+            Mat& mask = *((Mat*)mask_nativeObj);
+            minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc, mask);
+        } else {
+            minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
+        }
+
+        jdouble fill[6];
+        fill[0]=minVal;
+        fill[1]=maxVal;
+        fill[2]=minLoc.x;
+        fill[3]=minLoc.y;
+        fill[4]=maxLoc.x;
+        fill[5]=maxLoc.y;
+
+        env->SetDoubleArrayRegion(result, 0, 6, fill);
+
+	return result;
+
+    } catch(cv::Exception e) {
+        LOGD("Core::n_1minMaxLoc() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return NULL;
+    } catch (...) {
+        LOGD("Core::n_1minMaxLoc() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {core::minMaxLoc()}");
+        return NULL;
+    }
+}
+
+""",
+        }, # minMaxLoc
+
+        'getTextSize' :
+        {
+            'j_code'   :
+"""
+    // C++: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine);
+    //javadoc:getTextSize(text, fontFace, fontScale, thickness, baseLine)
+    public static Size getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine) {
+        if(baseLine != null && baseLine.length != 1)
+            throw new java.lang.IllegalArgumentException("'baseLine' must be 'int[1]' or 'null'.");
+        Size retVal = new Size(n_getTextSize(text, fontFace, fontScale, thickness, baseLine));
+        return retVal;
+    }
+""",
+            'jn_code'  :
+"""    private static native double[] n_getTextSize(String text, int fontFace, double fontScale, int thickness, int[] baseLine);\n""",
+            'cpp_code' :
+"""
+// C++: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine);
+
+JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Core_n_1getTextSize
+  (JNIEnv* env, jclass cls, jstring text, jint fontFace, jdouble fontScale, jint thickness, jintArray baseLine)
+{
+    try {
+        LOGD("Core::n_1getTextSize()");
+        jdoubleArray result;
+        result = env->NewDoubleArray(2);
+        if (result == NULL) {
+            return NULL; /* out of memory error thrown */
+        }
+
+        const char* utf_text = env->GetStringUTFChars(text, 0);
+        std::string n_text( utf_text ? utf_text : "" );
+        env->ReleaseStringUTFChars(text, utf_text);
+
+        int _baseLine;
+        int* pbaseLine = 0;
+
+        if (baseLine != NULL)
+            pbaseLine = &_baseLine;
+
+        cv::Size rsize = cv::getTextSize(n_text, (int)fontFace, (double)fontScale, (int)thickness, pbaseLine);
+
+        jdouble fill[2];
+        fill[0]=rsize.width;
+        fill[1]=rsize.height;
+
+        env->SetDoubleArrayRegion(result, 0, 2, fill);
+
+        if (baseLine != NULL)
+            env->SetIntArrayRegion(baseLine, 0, 1, pbaseLine);
+
+        return result;
+
+    } catch(cv::Exception e) {
+        LOGD("Core::n_1getTextSize() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return NULL;
+    } catch (...) {
+        LOGD("Core::n_1getTextSize() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {core::getTextSize()}");
+        return NULL;
+    }
+}
+
+""",
+        }, # getTextSize
+
+        "checkHardwareSupport" : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "setUseOptimized"      : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "useOptimized"         : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+
+    }, # Core
+
+    'Highgui' :
+    {
+        "namedWindow"       : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "destroyWindow"     : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "destroyAllWindows" : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "startWindowThread" : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "setWindowProperty" : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "getWindowProperty" : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "getTrackbarPos"    : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "setTrackbarPos"    : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "imshow"            : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+        "waitKey"           : {'j_code' : '', 'jn_code' : '', 'cpp_code' : '' },
+    }, # Highgui
+    
+    'CvANN_MLP_TrainParams':
+    {
+        "CvANN_MLP_TrainParams" : 
+        {
+            'j_code' : """
+//javadoc:CvANN_MLP_TrainParams::CvANN_MLP_TrainParams()
+public CvANN_MLP_TrainParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvANN_1MLP_1TrainParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvANN_MLP_TrainParams();
+}
+            """
+        },
+    },
+    
+    'CvBoostParams':
+    {
+        "CvBoostParams" : 
+        {
+            'j_code' : """
+//javadoc:CvBoostParams::CvBoostParams()
+public CvBoostParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvBoostParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvBoostParams();
+}
+            """
+        },
+    },
+    
+    'CvDTreeParams':
+    {
+        "CvDTreeParams" : 
+        {
+            'j_code' : """
+//javadoc:CvDTreeParams::CvDTreeParams()
+public CvDTreeParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvDTreeParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvDTreeParams();
+}
+            """
+        },
+    },
+    
+    'CvEMParams':
+    {
+        "CvEMParams" : 
+        {
+            'j_code' : """
+//javadoc:CvEMParams::CvEMParams()
+public CvEMParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvEMParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvEMParams();
+}
+            """
+        },
+    },
+    
+    'CvGBTreesParams':
+    {
+        "CvGBTreesParams" : 
+        {
+            'j_code' : """
+//javadoc:CvGBTreesParams::CvGBTreesParams()
+public CvGBTreesParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvGBTreesParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvGBTreesParams();
+}
+            """
+        },
+    },
+    
+    'CvParamGrid':
+    {
+        "CvParamGrid" : 
+        {
+            'j_code' : """
+//javadoc:CvParamGrid::CvParamGrid()
+public CvParamGrid() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvParamGrid_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvParamGrid();
+}
+            """
+        },
+    },
+    
+    'CvRTParams':
+    {
+        "CvRTParams" : 
+        {
+            'j_code' : """
+//javadoc:CvRTParams::CvRTParams()
+public CvRTParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvRTParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvRTParams();
+}
+            """
+        },
+    },
+    
+    'CvStatModel':
+    {
+        "CvStatModel" : 
+        {
+            'j_code' : """
+//javadoc:CvStatModel::CvStatModel()
+public CvStatModel() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvStatModel_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvStatModel();
+}
+            """
+        },
+    },
+    
+    'CvSVMParams':
+    {
+        "CvSVMParams" : 
+        {
+            'j_code' : """
+//javadoc:CvSVMParams::CvSVMParams()
+public CvSVMParams() {
+    nativeObj = n_newObj();
+}
+            """,
+            'jn_code' : 'private static native long n_newObj();',
+            'cpp_code' : """
+JNIEXPORT jlong JNICALL Java_org_opencv_ml_CvSVMParams_n_1newObj
+  (JNIEnv* env, jclass cls)
+{
+    return (jlong) new CvSVMParams();
+}
+            """
+        },
+    },
+}
+
+# { class : { func : {arg_name : ctype} } }
+func_arg_fix = {
+    '' : {
+        'randu'    : { 'low'     : 'double', 'high'   : 'double', },
+        'randn'    : { 'mean'    : 'double', 'stddev' : 'double', },
+        'inRange'  : { 'lowerb'  : 'Scalar', 'upperb' : 'Scalar', },
+        'goodFeaturesToTrack' : { 'corners' : 'vector_Point', },
+        'findFundamentalMat' : { 'points1' : 'vector_Point2d', 'points2' : 'vector_Point2d', },
+        'cornerSubPix' : { 'corners' : 'vector_Point2f', },
+        'minEnclosingCircle' : { 'points' : 'vector_Point2f', },
+        'findHomography' : { 'srcPoints' : 'vector_Point2f', 'dstPoints' : 'vector_Point2f', },
+        'solvePnP' : { 'objectPoints' : 'vector_Point3f', 'imagePoints' : 'vector_Point2f', },
+        'solvePnPRansac' : { 'objectPoints' : 'vector_Point3f', 'imagePoints' : 'vector_Point2f', },
+        'calcOpticalFlowPyrLK' : { 'prevPts' : 'vector_Point2f', 'nextPts' : 'vector_Point2f',
+                                   'status' : 'vector_uchar', 'err' : 'vector_float', },
+        'fitEllipse' : { 'points' : 'vector_Point2f', },
+        'fillPoly' : { 'pts' : 'vector_vector_Point', },
+        'polylines' : { 'pts' : 'vector_vector_Point', },
+        'fillConvexPoly' : { 'points' : 'vector_Point', },
+        'boundingRect' : { 'points' : 'vector_Point', },
+        #'approxPolyDP' : { 'curve' : 'vector_Point2f', 'CV_OUT approxCurve' : 'vector_Point2f', },
+        'arcLength' : { 'curve' : 'vector_Point2f', },
+        'isContourConvex' : { 'contour' : 'vector_Point2f', },
+        'pointPolygonTest' : { 'contour' : 'vector_Point2f', },
+        'minAreaRect' : { 'points' : 'vector_Point2f', },
+        'getAffineTransform' : { 'src' : 'vector_Point2f', 'dst' : 'vector_Point2f', },
+        'hconcat' : { 'src' : 'vector_Mat', },
+        'vconcat' : { 'src' : 'vector_Mat', },
+        
+    }, # '', i.e. no class
+} # func_arg_fix
+
+class ConstInfo(object):
+    def __init__(self, cname, name, val, addedManually=False):
+        self.cname = cname
+        self.name = re.sub(r"^Cv", "", name)
+        self.value = val
+        self.addedManually = addedManually
+
+
+class ClassPropInfo(object):
+    def __init__(self, decl): # [f_ctype, f_name, '', '/RW']
+        self.ctype = decl[0]
+        self.name = decl[1]
+        self.rw = "/RW" in decl[3]
+
+class ClassInfo(object):
+    def __init__(self, decl): # [ 'class/struct cname', [bases], [modlist] ]
+        name = decl[0]
+        name = name[name.find(" ")+1:].strip()
+        self.cname = self.name = self.jname = re.sub(r"^cv\.", "", name)
+        self.cname =self.cname.replace(".", "::")
+        self.methods = {}
+        self.methods_suffixes = {}
+        self.consts = [] # using a list to save the occurence order
+        self.private_consts = []
+        self.imports = set()
+        self.props= []
+        self.jname = self.name
+        for m in decl[2]:
+            if m.startswith("="):
+                self.jname = m[1:]
+
+
+class ArgInfo(object):
+    def __init__(self, arg_tuple): # [ ctype, name, def val, [mod], argno ]
+        self.pointer = False
+        ctype = arg_tuple[0]
+        if ctype.endswith("*"):
+            ctype = ctype[:-1]
+            self.pointer = True
+        self.ctype = ctype
+        self.name = arg_tuple[1]
+        self.defval = arg_tuple[2]
+        self.out = ""
+        if "/O" in arg_tuple[3]:
+            self.out = "O"
+        if "/IO" in arg_tuple[3]:
+            self.out = "IO"
+
+
+class FuncInfo(object):
+    def __init__(self, decl): # [ funcname, return_ctype, [modifiers], [args] ]
+        name = re.sub(r"^cv\.", "", decl[0])
+        self.cname = name.replace(".", "::")
+        classname = ""
+        dpos = name.rfind(".")
+        if dpos >= 0:
+            classname = name[:dpos]
+            name = name[dpos+1:]
+        self.classname = classname
+        self.jname = self.name = name
+        if "[" in name:
+            self.jname = "getelem"
+        for m in decl[2]:
+            if m.startswith("="):
+                self.jname = m[1:]
+        self.static = ["","static"][ "/S" in decl[2] ]
+        self.ctype = decl[1] or ""
+        self.args = []
+        arg_fix_map = func_arg_fix.get(classname, {}).get(self.jname, {})
+        for a in decl[3]:
+            arg = a[:]
+            arg[0] = arg_fix_map.get(arg[1], arg[0])
+            ai = ArgInfo(arg)
+            self.args.append(ai)
+
+
+
+class FuncFamilyInfo(object):
+    def __init__(self, decl): # [ funcname, return_ctype, [modifiers], [args] ]
+        self.funcs = []
+        self.funcs.append( FuncInfo(decl) )
+        self.jname = self.funcs[0].jname
+        self.isconstructor = self.funcs[0].name == self.funcs[0].classname
+
+
+
+    def add_func(self, fi):
+        self.funcs.append( fi )
+
+
+class JavaWrapperGenerator(object):
+    def __init__(self):
+        self.clear()
+
+    def clear(self):
+        self.classes = { "Mat" : ClassInfo([ 'class Mat', [], [] ]) }
+        self.module = ""
+        self.Module = ""
+        self.java_code= {} # { class : {j_code, jn_code} }
+        self.cpp_code = None
+        self.ported_func_list = []
+        self.skipped_func_list = []
+
+    def add_class_code_stream(self, class_name):
+        jname = self.classes[class_name].jname
+        self.java_code[class_name] = { "j_code" : StringIO(), "jn_code" : StringIO(), }
+        if class_name != self.Module:
+            self.java_code[class_name]["j_code"].write("""
+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.%(m)s;
+
+$imports
+
+// C++: class %(c)s
+//javadoc: %(c)s
+public class %(jc)s {
+
+    protected final long nativeObj;
+    protected %(jc)s(long addr) { nativeObj = addr; }
+
+""" % { 'm' : self.module, 'c' : class_name, 'jc' : jname } )
+
+        else: # class_name == self.Module
+            self.java_code[class_name]["j_code"].write("""
+//
+// This file is auto-generated. Please don't modify it!
+//
+package org.opencv.%(m)s;
+
+$imports
+
+public class %(jc)s {
+""" % { 'm' : self.module, 'jc' : jname } )
+
+        self.java_code[class_name]["jn_code"].write("""
+    //
+    // native stuff
+    //
+    static { System.loadLibrary("opencv_java"); }
+""" )
+
+
+
+    def add_class(self, decl):
+        classinfo = ClassInfo(decl)
+        if classinfo.name in class_ignore_list:
+            return
+        name = classinfo.name
+        if name in self.classes:
+            print "Generator error: class %s (%s) is duplicated" % \
+                    (name, classinfo.cname)
+            return
+        self.classes[name] = classinfo
+        if name in type_dict:
+            print "Duplicated class: " + name
+            return
+        type_dict[name] = \
+            { "j_type" : classinfo.jname,
+              "jn_type" : "long", "jn_args" : (("__int64", ".nativeObj"),),
+              "jni_name" : "(*("+name+"*)%(n)s_nativeObj)", "jni_type" : "jlong",
+              "suffix" : "J" }
+        type_dict[name+'*'] = \
+            { "j_type" : classinfo.jname,
+              "jn_type" : "long", "jn_args" : (("__int64", ".nativeObj"),),
+              "jni_name" : "("+name+"*)%(n)s_nativeObj", "jni_type" : "jlong",
+              "suffix" : "J" }
+
+        # missing_consts { Module : { public : [[name, val],...], private : [[]...] } }
+        if name in missing_consts:
+            if 'private' in missing_consts[name]:
+                for (n, val) in missing_consts[name]['private']:
+                    classinfo.private_consts.append( ConstInfo(n, n, val, True) )
+            if 'public' in missing_consts[name]:
+                for (n, val) in missing_consts[name]['public']:
+                    classinfo.consts.append( ConstInfo(n, n, val, True) )
+
+        # class props
+        for p in decl[3]:
+            if True: #"vector" not in p[0]:
+                classinfo.props.append( ClassPropInfo(p) )
+            else:
+                print "Skipped property: [%s]" % name, p
+
+        self.add_class_code_stream(name)
+
+
+    def add_const(self, decl): # [ "const cname", val, [], [] ]
+        name = decl[0].replace("const ", "").strip()
+        name = re.sub(r"^cv\.", "", name)
+        cname = name.replace(".", "::")
+        for c in const_ignore_list:
+            if re.match(c, name):
+                return
+        # class member?
+        dpos = name.rfind(".")
+        if dpos >= 0:
+            classname = name[:dpos]
+            name = name[dpos+1:]
+        else:
+            classname = self.Module
+        if classname not in self.classes:
+            # this class isn't wrapped
+            # skipping this const
+            return
+
+        consts = self.classes[classname].consts
+        for c in const_private_list:
+            if re.match(c, name):
+                consts = self.classes[classname].private_consts
+                break
+
+        constinfo = ConstInfo(cname, name, decl[1])
+        # checking duplication
+        for list in self.classes[classname].consts, self.classes[classname].private_consts:
+            for c in list:
+                if c.name == constinfo.name:
+                    if c.addedManually:
+                        return
+                    print "Generator error: constant %s (%s) is duplicated" \
+                            % (constinfo.name, constinfo.cname)
+                    sys.exit(-1)
+
+        consts.append(constinfo)
+
+    def add_func(self, decl):
+        ffi = FuncFamilyInfo(decl)
+        classname = ffi.funcs[0].classname or self.Module
+        if classname in class_ignore_list:
+            return
+        if classname in ManualFuncs and ffi.jname in ManualFuncs[classname]:
+            return
+        if classname not in self.classes:
+            print "Generator error: the class %s for method %s is missing" % \
+                    (classname, ffi.jname)
+            sys.exit(-1)
+        func_map = self.classes[classname].methods
+        if ffi.jname in func_map:
+            func_map[ffi.jname].add_func(ffi.funcs[0])
+        else:
+            func_map[ffi.jname] = ffi
+
+    def save(self, path, buf):
+        f = open(path, "wt")
+        f.write(buf)
+        f.close()
+
+    def gen(self, srcfiles, module, output_path):
+        self.clear()
+        self.module = module
+        self.Module = module.capitalize()
+        parser = hdr_parser.CppHeaderParser()
+
+        self.add_class( ['class ' + self.Module, [], [], []] ) # [ 'class/struct cname', [bases], [modlist] [props] ]
+
+        # scan the headers and build more descriptive maps of classes, consts, functions
+        for hdr in srcfiles:
+            decls = parser.parse(hdr)
+            for decl in decls:
+                name = decl[0]
+                if name.startswith("struct") or name.startswith("class"):
+                    self.add_class(decl)
+                elif name.startswith("const"):
+                    self.add_const(decl)
+                else: # function
+                    self.add_func(decl)
+                    
+        #FIXME: BackgroundSubtractor is merged into BackgroundSubtractorMOG because of inheritance
+        if "BackgroundSubtractor" in self.classes:
+            bs = self.classes["BackgroundSubtractor"]
+            bsmog = self.classes["BackgroundSubtractorMOG"]
+            for name, mtd in bs.methods.items():
+                for fn in mtd.funcs:
+                    fn.classname = "BackgroundSubtractorMOG"
+                bsmog.methods[name] = mtd;
+            del self.classes["BackgroundSubtractor"]
+
+        self.cpp_code = StringIO()
+        self.cpp_code.write("""
+//
+// This file is auto-generated, please don't edit!
+//
+
+#include <jni.h>
+
+#include "converters.h"
+
+#ifdef DEBUG
+#include <android/log.h>
+#define MODULE_LOG_TAG "OpenCV.%(m)s"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
+#else //DEBUG
+#define LOGD(...)
+#endif //DEBUG
+
+#include "opencv2/%(m)s/%(m)s.hpp"
+
+using namespace cv;
+
+extern "C" {
+
+""" % {'m' : module} )
+
+        # generate code for the classes
+        for name in self.classes.keys():
+            if name == "Mat":
+                continue
+            self.gen_class(name)
+            # saving code streams
+            imports = "\n".join([ "import %s;" % c for c in \
+                sorted(self.classes[name].imports) if not c.startswith('org.opencv.'+self.module) ])
+            self.java_code[name]["j_code"].write("\n\n%s\n}\n" % self.java_code[name]["jn_code"].getvalue())
+            java_code = self.java_code[name]["j_code"].getvalue()
+            java_code = Template(java_code).substitute(imports = imports)
+            self.save("%s/%s+%s.java" % (output_path, module, self.classes[name].jname), java_code)
+
+        self.cpp_code.write( '\n} // extern "C"\n' )
+        self.save(output_path+"/"+module+".cpp",  self.cpp_code.getvalue())
+
+        # report
+        report = StringIO()
+        report.write("PORTED FUNCs LIST (%i of %i):\n\n" % \
+            (len(self.ported_func_list), len(self.ported_func_list)+ len(self.skipped_func_list))
+        )
+        report.write("\n".join(self.ported_func_list))
+        report.write("\n\nSKIPPED FUNCs LIST (%i of %i):\n\n" % \
+            (len(self.skipped_func_list), len(self.ported_func_list)+ len(self.skipped_func_list))
+        )
+        report.write("".join(self.skipped_func_list))
+        self.save(output_path+"/"+module+".txt", report.getvalue())
+
+        print "Done %i of %i funcs." % (len(self.ported_func_list), len(self.ported_func_list)+ len(self.skipped_func_list))
+
+
+
+    def get_imports(self, scope_classname, ctype):
+        imports = self.classes[scope_classname or self.Module].imports
+        if ctype.startswith('vector'):
+            imports.add("java.util.List")
+            imports.add("org.opencv.core.Mat")
+            imports.add("org.opencv.utils.Converters")
+            ctype = ctype.replace('vector_', '')
+        j_type = ''
+        if ctype in type_dict:
+            j_type = type_dict[ctype]['j_type']
+        if j_type in ( "CvType", "Mat", "Point", "Point3", "Range", "Rect", "RotatedRect", "Scalar", "Size", "TermCriteria" ):
+            imports.add("org.opencv.core." + j_type)
+        if j_type == 'String':
+            imports.add("java.lang.String")
+
+
+
+    def gen_func(self, fi, prop_name=''):
+        j_code   = self.java_code[fi.classname or self.Module]["j_code"]
+        jn_code  = self.java_code[fi.classname or self.Module]["jn_code"]
+        cpp_code = self.cpp_code
+
+        # c_decl
+        # e.g: void add(Mat src1, Mat src2, Mat dst, Mat mask = Mat(), int dtype = -1)
+        if prop_name:
+            c_decl = "%s %s::%s" % (fi.ctype, fi.classname, prop_name)
+        else:
+            decl_args = []
+            for a in fi.args:
+                s = a.ctype
+                if a.pointer:
+                    s += "*"
+                elif a.out:
+                    s += "&"
+                s += " " + a.name
+                if a.defval:
+                    s += " = "+a.defval
+                decl_args.append(s)
+            c_decl = "%s %s %s(%s)" % ( fi.static, fi.ctype, fi.cname, ", ".join(decl_args) )
+
+        # java comment
+        j_code.write( "\n    //\n    // C++: %s\n    //\n\n" % c_decl )
+        # check if we 'know' all the types
+        if fi.ctype not in type_dict: # unsupported ret type
+            msg = "// Return type '%s' is not supported, skipping the function\n\n" % fi.ctype
+            self.skipped_func_list.append(c_decl + "\n" + msg)
+            j_code.write( " "*4 + msg )
+            print "SKIP:", c_decl, "\n\tdue to RET type", fi.ctype
+            return
+        for a in fi.args:
+            if a.ctype not in type_dict:
+                msg = "// Unknown type '%s' (%s), skipping the function\n\n" % (a.ctype, a.out or "I")
+                self.skipped_func_list.append(c_decl + "\n" + msg)
+                j_code.write( " "*4 + msg )
+                print "SKIP:", c_decl, "\n\tdue to ARG type", a.ctype, "/" + (a.out or "I")
+                return
+
+        self.ported_func_list.append(c_decl)
+
+        # jn & cpp comment
+        jn_code.write( "\n    // C++: %s\n" % c_decl )
+        cpp_code.write( "\n//\n// %s\n//\n" % c_decl )
+
+        # java args
+        args = fi.args[:] # copy
+        suffix_counter = int( self.classes[fi.classname or self.Module].methods_suffixes.get(fi.jname, -1) )
+        while True:
+            suffix_counter += 1
+            self.classes[fi.classname or self.Module].methods_suffixes[fi.jname] = suffix_counter
+             # java native method args
+            jn_args = []
+            # jni (cpp) function args
+            jni_args = [ArgInfo([ "env", "env", "", [], "" ]), ArgInfo([ "cls", "cls", "", [], "" ])]
+            j_prologue = []
+            j_epilogue = []
+            c_prologue = []
+            c_epilogue = []
+            if type_dict[fi.ctype]["jni_type"] == "jdoubleArray":
+                fields = type_dict[fi.ctype]["jn_args"]
+                c_epilogue.append( \
+                    ("jdoubleArray _da_retval_ = env->NewDoubleArray(%(cnt)i);  " +
+                     "jdouble _tmp_retval_[%(cnt)i] = {%(args)s}; " +
+                     "env->SetDoubleArrayRegion(_da_retval_, 0, %(cnt)i, _tmp_retval_);") %
+                    { "cnt" : len(fields), "args" : ", ".join(["_retval_" + f[1] for f in fields]) } )
+            if fi.classname and fi.ctype and not fi.static: # non-static class method except c-tor
+                # adding 'self'
+                jn_args.append ( ArgInfo([ "__int64", "nativeObj", "", [], "" ]) )
+                jni_args.append( ArgInfo([ "__int64", "self", "", [], "" ]) )
+            self.get_imports(fi.classname, fi.ctype)
+            for a in args:
+                self.get_imports(fi.classname, a.ctype)
+                if "vector" in a.ctype: # pass as Mat
+                    jn_args.append  ( ArgInfo([ "__int64", "%s_mat.nativeObj" % a.name, "", [], "" ]) )
+                    jni_args.append ( ArgInfo([ "__int64", "%s_mat_nativeObj" % a.name, "", [], "" ]) )
+                    c_prologue.append( type_dict[a.ctype]["jni_var"] % {"n" : a.name} + ";" )
+                    c_prologue.append( "Mat& %(n)s_mat = *((Mat*)%(n)s_mat_nativeObj)" % {"n" : a.name} + ";" )
+                    if "I" in a.out or not a.out:
+                        if a.ctype.startswith("vector_vector_"):
+                            self.classes[fi.classname or self.Module].imports.add("java.util.ArrayList")
+                            j_prologue.append( "List<Mat> %(n)s_tmplm = new ArrayList<Mat>((%(n)s != null) ? %(n)s.size() : 0);" % {"n" : a.name } )
+                            j_prologue.append( "Mat %(n)s_mat = Converters.%(t)s_to_Mat(%(n)s, %(n)s_tmplm);" % {"n" : a.name, "t" : a.ctype} )
+                        else:
+                            j_prologue.append( "Mat %(n)s_mat = Converters.%(t)s_to_Mat(%(n)s);" % {"n" : a.name, "t" : a.ctype} )
+                        c_prologue.append( "Mat_to_%(t)s( %(n)s_mat, %(n)s );" % {"n" : a.name, "t" : a.ctype} )
+                    else:
+                        j_prologue.append( "Mat %s_mat = new Mat();" % a.name )
+                    if "O" in a.out:
+                        if type_dict[a.ctype]["j_type"] != "Mat":
+                            j_epilogue.append("Converters.Mat_to_%(t)s(%(n)s_mat, %(n)s);" % {"t" : a.ctype, "n" : a.name})
+                        c_epilogue.append( "%(t)s_to_Mat( %(n)s, %(n)s_mat );" % {"n" : a.name, "t" : a.ctype} )
+                else:
+                    fields = type_dict[a.ctype].get("jn_args", ((a.ctype, ""),))
+                    if "I" in a.out or not a.out or a.ctype in self.classes: # input arg, pass by primitive fields
+                        for f in fields:
+                            jn_args.append ( ArgInfo([ f[0], a.name + f[1], "", [], "" ]) )
+                            jni_args.append( ArgInfo([ f[0], a.name + f[1].replace(".","_").replace("[","").replace("]",""), "", [], "" ]) )
+                    if a.out and a.ctype not in self.classes: # out arg, pass as double[]
+                        jn_args.append ( ArgInfo([ "double[]", "%s_out" % a.name, "", [], "" ]) )
+                        jni_args.append ( ArgInfo([ "double[]", "%s_out" % a.name, "", [], "" ]) )
+                        j_prologue.append( "double[] %s_out = new double[%i];" % (a.name, len(fields)) )
+                        c_epilogue.append( \
+                            "jdouble tmp_%(n)s[%(cnt)i] = {%(args)s}; env->SetDoubleArrayRegion(%(n)s_out, 0, %(cnt)i, tmp_%(n)s);" %
+                            { "n" : a.name, "cnt" : len(fields), "args" : ", ".join([a.name + f[1] for f in fields]) } )
+                        if a.ctype in ('bool', 'int', 'long', 'float', 'double'):
+                            j_epilogue.append('if(%(n)s!=null) %(n)s[0] = (%(t)s)%(n)s_out[0];' % {'n':a.name,'t':a.ctype})
+                        else:
+                            set_vals = []
+                            i = 0
+                            for f in fields:
+                                set_vals.append( "%(n)s%(f)s = %(t)s%(n)s_out[%(i)i]" %
+                                    {"n" : a.name, "t": ("("+type_dict[f[0]]["j_type"]+")", "")[f[0]=="double"], "f" : f[1], "i" : i}
+                                )
+                                i += 1
+                            j_epilogue.append( "if("+a.name+"!=null){ " + "; ".join(set_vals) + "; } ")
+
+
+            # java part:
+            # private java NATIVE method decl
+            # e.g.
+            # private static native void add_0(long src1, long src2, long dst, long mask, int dtype);
+            jn_code.write( Template(\
+                "    private static native $type $name($args);\n").substitute(\
+                type = type_dict[fi.ctype].get("jn_type", "double[]"), \
+                name = fi.jname + '_' + str(suffix_counter), \
+                args = ", ".join(["%s %s" % (type_dict[a.ctype]["jn_type"], a.name.replace(".","_").replace("[","").replace("]","")) for a in jn_args])
+            ) );
+
+            # java part:
+
+            #java doc comment
+            f_name = fi.name
+            if fi.classname:
+                f_name = fi.classname + "::" + fi.name
+            java_doc = "//javadoc: " + f_name + "(%s)" % ", ".join([a.name for a in args])
+            j_code.write(" "*4 + java_doc + "\n")
+
+            # public java wrapper method impl (calling native one above)
+            # e.g.
+            # public static void add( Mat src1, Mat src2, Mat dst, Mat mask, int dtype )
+            # { add_0( src1.nativeObj, src2.nativeObj, dst.nativeObj, mask.nativeObj, dtype );  }
+            ret_type = fi.ctype
+            if fi.ctype.endswith('*'):
+                ret_type = ret_type[:-1]
+            ret_val = type_dict[ret_type]["j_type"] + " retVal = "
+            tail = ""
+            ret = "return retVal;"
+            if ret_type.startswith('vector'):
+                ret_val = "Mat retValMat = new Mat("
+                tail = ")"
+                j_type = type_dict[ret_type]["j_type"]
+                j_prologue.append( j_type + ' retVal = new Array' + j_type+'();')
+                self.classes[fi.classname or self.Module].imports.add('java.util.ArrayList')
+                j_epilogue.append('Converters.Mat_to_' + ret_type + '(retValMat, retVal);')
+            elif ret_type == "void":
+                ret_val = ""
+                ret = "return;"
+            elif ret_type == "": # c-tor
+                ret_val = "nativeObj = "
+                ret = "return;"
+            elif ret_type in self.classes: # wrapped class
+                ret_val = type_dict[ret_type]["j_type"] + " retVal = new " + self.classes[ret_type].jname + "("
+                tail = ")"
+            elif "jn_type" not in type_dict[ret_type]:
+                ret_val = type_dict[fi.ctype]["j_type"] + " retVal = new " + type_dict[ret_type]["j_type"] + "("
+                tail = ")"
+
+            static = "static"
+            if fi.classname:
+                static = fi.static
+
+            j_args = []
+            for a in args:
+                jt = type_dict[a.ctype]["j_type"]
+                if a.out and a.ctype in ('bool', 'int', 'long', 'float', 'double'):
+                    jt += '[]'
+                j_args.append( jt + ' ' + a.name )
+
+            j_code.write( Template(\
+"""    public $static $j_type $j_name($j_args)
+    {
+        $prologue
+        $ret_val$jn_name($jn_args_call)$tail;
+        $epilogue
+        $ret
+    }
+
+"""
+                ).substitute(\
+                    ret = ret, \
+                    ret_val = ret_val, \
+                    tail = tail, \
+                    prologue = "\n        ".join(j_prologue), \
+                    epilogue = "\n        ".join(j_epilogue), \
+                    static=static, \
+                    j_type=type_dict[fi.ctype]["j_type"], \
+                    j_name=fi.jname, \
+                    j_args=", ".join(j_args), \
+                    jn_name=fi.jname + '_' + str(suffix_counter), \
+                    jn_args_call=", ".join( [a.name for a in jn_args] ),\
+                )
+            )
+
+
+            # cpp part:
+            # jni_func(..) { _retval_ = cv_func(..); return _retval_; }
+            ret = "return _retval_;"
+            default = "return 0;"
+            if fi.ctype == "void":
+                ret = "return;"
+                default = "return;"
+            elif not fi.ctype: # c-tor
+                ret = "return (jlong) _retval_;"
+            elif fi.ctype.startswith('vector'): # c-tor
+                ret = "return (jlong) _retval_;"
+            elif fi.ctype == "string":
+                ret = "return env->NewStringUTF(_retval_.c_str());"
+                default = 'return env->NewStringUTF("");'
+            elif fi.ctype in self.classes: # wrapped class:
+                ret = "return (jlong) new %s(_retval_);" % fi.ctype
+            elif ret_type in self.classes: # pointer to wrapped class:
+                ret = "return (jlong) _retval_;"
+            elif type_dict[fi.ctype]["jni_type"] == "jdoubleArray":
+                ret = "return _da_retval_;"
+
+            # hack: replacing func call with property set/get
+            name = fi.name
+            if prop_name:
+                if args:
+                    name = prop_name + " = "
+                else:
+                    name = prop_name + ";//"
+
+            cvname = "cv::" + name
+            retval = fi.ctype + " _retval_ = "
+            if fi.ctype == "void":
+                retval = ""
+            elif fi.ctype.startswith('vector'):
+                retval = type_dict[fi.ctype]['jni_var'] % {"n" : '_ret_val_vector_'} + " = "
+                c_epilogue.append("Mat* _retval_ = new Mat();")
+                c_epilogue.append(fi.ctype+"_to_Mat(_ret_val_vector_, *_retval_);")
+            if fi.classname:
+                if not fi.ctype: # c-tor
+                    retval = fi.classname + "* _retval_ = "
+                    cvname = "new " + fi.classname
+                elif fi.static:
+                    cvname = "%s::%s" % (fi.classname, name)
+                else:
+                    cvname = "me->" + name
+                    c_prologue.append(\
+                        "%(cls)s* me = (%(cls)s*) self; //TODO: check for NULL" \
+                            % { "cls" : fi.classname} \
+                    )
+            cvargs = []
+            for a in args:
+                if a.pointer:
+                    jni_name = "&%(n)s"
+                else:
+                    jni_name = "%(n)s"
+                cvargs.append( type_dict[a.ctype].get("jni_name", jni_name) % {"n" : a.name})
+                if "vector" not in a.ctype :
+                    if ("I" in a.out or not a.out or a.ctype in self.classes) and "jni_var" in type_dict[a.ctype]: # complex type
+                        c_prologue.append(type_dict[a.ctype]["jni_var"] % {"n" : a.name} + ";")
+                    if a.out and "I" not in a.out and a.ctype not in self.classes:
+                        c_prologue.append("%s %s;" % (a.ctype, a.name))
+
+            rtype = type_dict[fi.ctype].get("jni_type", "jdoubleArray")
+            clazz = self.Module
+            if fi.classname:
+                clazz = self.classes[fi.classname].jname
+            cpp_code.write ( Template( \
+"""
+
+JNIEXPORT $rtype JNICALL Java_org_opencv_${module}_${clazz}_$fname
+  ($args)
+{
+    try {
+        LOGD("$module::$fname()");
+        $prologue
+        $retval$cvname( $cvargs );
+        $epilogue
+        $ret
+    } catch(cv::Exception e) {
+        LOGD("$module::$fname() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        $default
+    } catch (...) {
+        LOGD("$module::$fname() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {$module::$fname()}");
+        $default
+    }
+}
+
+
+""" ).substitute( \
+        rtype = rtype, \
+        module = self.module, \
+        clazz = clazz.replace('_', '_1'), \
+        fname = (fi.jname + '_' + str(suffix_counter)).replace('_', '_1'), \
+        args = ", ".join(["%s %s" % (type_dict[a.ctype].get("jni_type"), a.name) for a in jni_args]), \
+        prologue = "\n        ".join(c_prologue), \
+        epilogue = "  ".join(c_epilogue), \
+        ret = ret, \
+        cvname = cvname, \
+        cvargs = ", ".join([a for a in cvargs]), \
+        default = default, \
+        retval = retval, \
+    ) )
+
+            # processing args with default values
+            if args and args[-1].defval:
+                a = args.pop()
+            else:
+                break
+
+
+
+    def gen_class(self, name):
+        # generate code for the class
+        ci = self.classes[name]
+        # constants
+        if ci.private_consts:
+            self.java_code[name]['j_code'].write("""
+    private static final int
+            %s;\n\n""" % (",\n"+" "*12).join(["%s = %s" % (c.name, c.value) for c in ci.private_consts])
+            )
+        if ci.consts:
+            self.java_code[name]['j_code'].write("""
+    public static final int
+            %s;\n\n""" % (",\n"+" "*12).join(["%s = %s" % (c.name, c.value) for c in ci.consts])
+            )
+        # c-tors
+        fflist = ci.methods.items()
+        fflist.sort()
+        for n, ffi in fflist:
+            if ffi.isconstructor:
+                for fi in ffi.funcs:
+                    fi.jname = ci.jname
+                    self.gen_func(fi)
+        # other methods
+        for n, ffi in fflist:
+            if not ffi.isconstructor:
+                for fi in ffi.funcs:
+                    self.gen_func(fi)
+        # props
+        for pi in ci.props:
+            # getter
+            getter_name = name + ".get_" + pi.name
+            #print getter_name
+            fi = FuncInfo( [getter_name, pi.ctype, [], []] ) # [ funcname, return_ctype, [modifiers], [args] ]
+            self.gen_func(fi, pi.name)
+            if pi.rw:
+                #setter
+                setter_name = name + ".set_" + pi.name
+                #print setter_name
+                fi = FuncInfo( [ setter_name, "void", [], [ [pi.ctype, pi.name, "", [], ""] ] ] )
+                self.gen_func(fi, pi.name)
+
+        # manual ports
+        if name in ManualFuncs:
+            for func in ManualFuncs[name].keys():
+                self.java_code[name]["j_code"].write ( ManualFuncs[name][func]["j_code"] )
+                self.java_code[name]["jn_code"].write( ManualFuncs[name][func]["jn_code"] )
+                self.cpp_code.write( ManualFuncs[name][func]["cpp_code"] )
+
+        if name != self.Module:
+            # finalize()
+            self.java_code[name]["j_code"].write(
+"""
+    @Override
+    protected void finalize() throws Throwable {
+        delete(nativeObj);
+        super.finalize();
+    }
+""" )
+
+            self.java_code[name]["jn_code"].write(
+"""
+    // native support for java finalize()
+    private static native void delete(long nativeObj);
+""" )
+
+            # native support for java finalize()
+            self.cpp_code.write( \
+"""
+//
+//  native support for java finalize()
+//  static void %(cls)s::delete( __int64 self )
+//
+
+JNIEXPORT void JNICALL Java_org_opencv_%(module)s_%(j_cls)s_delete
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    delete (%(cls)s*) self;
+}
+
+""" % {"module" : module, "cls" : name, "j_cls" : ci.jname}
+            )
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 4:
+        print "Usage:\n", \
+            os.path.basename(sys.argv[0]), \
+            "<full path to hdr_parser.py> <module name> <C++ header> [<C++ header>...]"
+        print "Current args are: ", ", ".join(["'"+a+"'" for a in sys.argv])
+        exit(0)
+
+    dstdir = "."
+    hdr_parser_path = os.path.abspath(sys.argv[1])
+    if hdr_parser_path.endswith(".py"):
+        hdr_parser_path = os.path.dirname(hdr_parser_path)
+    sys.path.append(hdr_parser_path)
+    import hdr_parser
+    module = sys.argv[2]
+    srcfiles = sys.argv[3:]
+    print "Generating module '" + module + "' from headers:\n\t" + "\n\t".join(srcfiles)
+    generator = JavaWrapperGenerator()
+    generator.gen(srcfiles, module, dstdir)
+
diff --git a/modules/java/gen_javadoc.py b/modules/java/gen_javadoc.py
new file mode 100644
index 0000000000..215495f5e2
--- /dev/null
+++ b/modules/java/gen_javadoc.py
@@ -0,0 +1,220 @@
+import os, sys, re, string, glob
+allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "haartraining", "java", "python", "stitching", "traincascade", "ts"]
+verbose = False
+show_warnings = True
+show_errors = True
+
+class JavadocGenerator(object):
+    def __init__(self, definitions = {}, javadoc_marker = "//javadoc:"):
+        self.definitions = definitions
+        self.javadoc_marker = javadoc_marker
+        self.markers_processed = 0
+        self.markers_documented = 0
+        self.params_documented = 0
+        self.params_undocumented = 0
+
+    def parceJavadocMarker(self, line):
+        assert line.lstrip().startswith(self.javadoc_marker)
+        offset = line[:line.find(self.javadoc_marker)]
+        line = line.strip()[len(self.javadoc_marker):]
+        args_start = line.rfind("(")
+        args_end = line.rfind(")")
+        assert args_start * args_end > 0
+        if args_start >= 0:
+            assert args_start < args_end
+            name = line[:args_start].strip()
+            if name.startswith("java"):
+                name = name[4:]
+            return (name, offset,  filter(None, list(arg.strip() for arg in line[args_start+1:args_end].split(","))))
+        name = line.strip()
+        if name.startswith("java"):
+            name = name[4:]
+        return (name, offset, [])
+
+    def document(self, infile, outfile):
+        inf = open(infile, "rt")
+        outf = open(outfile, "wt")
+        module = os.path.splitext(os.path.basename(infile))[0].split("+")[0]
+        if module not in allmodules:
+            module = "unknown"
+        try:
+            for l in inf.readlines():
+                org = l
+                l = l.replace(" ", "").replace("\t", "")#remove all whitespace
+                if l.startswith(self.javadoc_marker):
+                    marker = self.parceJavadocMarker(l)
+                    self.markers_processed += 1
+                    decl = self.definitions.get(marker[0],None)
+                    if decl:
+                        javadoc = self.makeJavadoc(decl, marker[2])
+                        if verbose:
+                            print
+                            print "Javadoc for \"%s\" File: %s (line %s)" % (decl["name"], decl["file"], decl["line"])
+                            print javadoc
+                        for line in javadoc.split("\n"):
+                            outf.write(marker[1] + line + "\n")
+                        self.markers_documented += 1
+                    elif show_errors:
+                        print >> sys.stderr, "gen_javadoc error: could not find documentation for %s (module: %s)" % (l.lstrip()[len(self.javadoc_marker):-1].strip(), module)
+                else:
+                    outf.write(org.replace("\t", "    ").rstrip()+"\n")
+        except:
+            inf.close()
+            outf.close()
+            os.remove(outfile)
+            raise
+        else:
+            inf.close()
+            outf.close()
+
+    def ReformatForJavadoc(self, s):
+        out = ""
+        for term in s.split("\n"):
+            if term.startswith("*") or term.startswith("#."):
+                term = "  " + term
+            if not term:
+                out += " *\n"
+            else:
+                pos_start = 0
+                pos_end = min(77, len(term)-1)
+                while pos_start < pos_end:
+                    if pos_end - pos_start == 77:
+                        while pos_end >= pos_start+60:
+                            if not term[pos_end].isspace():
+                                pos_end -= 1
+                            else:
+                                break
+                        if pos_end < pos_start+60:
+                            pos_end = min(pos_start + 77, len(term)-1)
+                            while pos_end < len(term):
+                                if not term[pos_end].isspace():
+                                    pos_end += 1
+                                else:
+                                    break
+                    out += " * " + term[pos_start:pos_end+1].rstrip() + "\n"
+                    pos_start = pos_end + 1
+                    pos_end = min(pos_start + 77, len(term)-1)
+        return out
+
+    def getJavaName(self, decl):
+        name = "org.opencv."
+        name += decl["module"]
+        if "class" in decl:
+            name += "." + decl["class"]
+        else:
+            name += "." + decl["module"].capitalize()
+        if "method" in decl:
+            name += "." + decl["method"]
+        return name
+
+    def getDocURL(self, decl):
+        url = "http://opencv.itseez.com/modules/"
+        url += decl["module"]
+        url += "/doc/"
+        url += os.path.basename(decl["file"]).replace(".rst",".html")
+        url += "#" + decl["name"].replace("::","-").replace("()","").replace("=","").strip().rstrip("_").replace(" ","-").replace("_","-").lower()
+        return url
+
+    def makeJavadoc(self, decl, args = None):
+        doc = ""
+        prefix = "/**\n"
+
+        if decl.get("isclass", False):
+            decl_type = "class"
+        elif decl.get("isstruct", False):
+            decl_type = "struct"
+        elif "class" in decl:
+            decl_type = "method"
+        else:
+            decl_type = "function"
+
+        # brief goes first
+        if "brief" in decl:
+            doc += prefix + self.ReformatForJavadoc(decl["brief"])
+            prefix = " *\n"
+        elif "long" not in decl:
+            if show_warnings:
+                print >> sys.stderr, "gen_javadoc warning: no description for " + decl_type + " \"%s\" File: %s (line %s)" % (func["name"], func["file"], func["line"])
+            doc += prefix + self.ReformatForJavadoc("This " + decl_type + " is undocumented")
+            prefix = " *\n"
+    
+        # long goes after brief
+        if "long" in decl:
+            doc += prefix  + self.ReformatForJavadoc(decl["long"])
+            prefix = " *\n"
+
+        # @param tags
+        if args and (decl_type == "method" or decl_type == "function"):
+            documented_params = decl.get("params",{})
+            for arg in args:
+                arg_doc = documented_params.get(arg, None)
+                if not arg_doc:
+                    arg_doc = "a " + arg
+                    if show_warnings:
+                        print >> sys.stderr, "gen_javadoc warning: parameter \"%s\" of \"%s\" is undocumented. File: %s (line %s)" % (arg, decl["name"], decl["file"], decl["line"])
+                    self.params_undocumented += 1
+                else:
+                    self.params_documented += 1
+                doc += prefix + self.ReformatForJavadoc("@param " + arg + " " + arg_doc)
+                prefix = ""
+            prefix = " *\n"
+
+        # @see tags
+        # always link to documentation
+        doc += prefix + " * @see <a href=\"" + self.getDocURL(decl) + "\">" + self.getJavaName(decl) + "</a>\n"
+        prefix = ""
+        # other links
+        if "seealso" in decl:
+            for see in decl["seealso"]:
+                seedecl = self.definitions.get(see,None)
+                if seedecl:
+                    doc += prefix + " * @see " + self.getJavaName(seedecl) + "\n"
+                else:
+                    doc += prefix + " * @see " + see.replace("::",".") + "\n"
+        prefix = " *\n"
+
+        #doc += prefix + " * File: " + decl["file"] + " (line " + str(decl["line"]) + ")\n"
+
+        return (doc + " */").replace("::",".")
+
+    def printSummary(self):
+        print
+        print "Javadoc Generator Summary:"
+        print "  Total markers:        %s" % self.markers_processed
+        print "  Undocumented markers: %s" % (self.markers_processed - self.markers_documented)
+        print "  Generated comments:   %s" % self.markers_documented
+
+        print
+        print "  Documented params:    %s" % self.params_documented
+        print "  Undocumented params:  %s" % self.params_undocumented
+        print
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print "Usage:\n", os.path.basename(sys.argv[0]), " <input dir1> [<input dir2> [...]]"
+        exit(0)
+   
+    selfpath = os.path.dirname(os.path.abspath(sys.argv[0]))
+    hdr_parser_path = os.path.join(selfpath, "../python/src2")
+    
+    sys.path.append(selfpath)
+    sys.path.append(hdr_parser_path)
+    import hdr_parser
+    import rst_parser
+
+    print "Parsing documentation..."
+    parser = rst_parser.RstParser(hdr_parser.CppHeaderParser())
+    for m in allmodules:
+        parser.parse(m, os.path.join(selfpath, "../" + m))
+        
+    parser.printSummary()
+
+    print "Generating javadoc comments..."
+    generator = JavadocGenerator(parser.definitions)
+    for i in range(1, len(sys.argv)):
+        folder = os.path.abspath(sys.argv[i])
+        for jfile in [f for f in glob.glob(os.path.join(folder,"*.java")) if not f.endswith("-jdoc.java")]:
+            outfile = os.path.abspath(os.path.basename(jfile).replace(".java", "-jdoc.java"))
+            generator.document(jfile, outfile)
+
+    generator.printSummary()
diff --git a/modules/java/rst_parser.py b/modules/java/rst_parser.py
new file mode 100644
index 0000000000..4e519af542
--- /dev/null
+++ b/modules/java/rst_parser.py
@@ -0,0 +1,680 @@
+import os, sys, re, string, glob
+allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "haartraining", "java", "python", "stitching", "traincascade", "ts"]
+verbose = False
+show_warnings = True
+show_errors = True
+
+class DeclarationParser(object):
+    def __init__(self, line=None):
+        if line is None:
+            self.fdecl = ""
+            self.lang = ""
+            self.balance = 0
+            return
+        self.lang = self.getLang(line)
+        assert self.lang is not None
+        self.fdecl = line[line.find("::")+2:].strip()
+        self.balance = self.fdecl.count("(") - self.fdecl.count(")")
+        assert self.balance >= 0
+
+    def append(self, line):
+        self.fdecl += line
+        self.balance = self.fdecl.count("(") - self.fdecl.count(")")
+
+    def isready(self):
+        return self.balance == 0
+
+    def getLang(self, line):
+        if line.startswith(".. ocv:function::"):
+            return "C++"
+        if line.startswith(".. ocv:cfunction::"):
+            return "C"
+        if line.startswith(".. ocv:pyfunction::"):
+            return "Python2"
+        if line.startswith(".. ocv:pyoldfunction::"):
+            return "Python1"
+        if line.startswith(".. ocv:jfunction::"):
+            return "Java"
+        return None
+    
+    def hasDeclaration(self, line):
+        return self.getLang(line) is not None
+
+class ParamParser(object):
+    def __init__(self, line=None):
+        if line is None:
+            self.prefix = ""
+            self.name = ""
+            self.comment = ""
+            self.active = False
+            return
+        offset = line.find(":param")
+        assert offset > 0
+        self.prefix = line[:offset]
+        assert self.prefix==" "*len(self.prefix), ":param definition should be prefixed with spaces"
+        line = line[offset + 6:].lstrip()
+        name_end = line.find(":")
+        assert name_end > 0
+        self.name = line[:name_end]
+        self.comment = line[name_end+1:].lstrip()
+        self.active = True
+
+    def append(self, line):
+        assert self.active
+        if (self.hasDeclaration(line)):
+            self.active = False
+        elif line.startswith(self.prefix) or not line:
+            self.comment += "\n" + line.lstrip()
+        else:
+            self.active = False
+            
+    def hasDeclaration(self, line):
+        return line.lstrip().startswith(":param")
+
+class RstParser(object):
+    def __init__(self, cpp_parser):
+        self.cpp_parser = cpp_parser
+        self.definitions = {}
+        self.sections_parsed = 0
+        self.sections_total = 0
+        self.sections_skipped = 0
+
+    def parse(self, module_name, module_path=None):
+        if module_path is None:
+            module_path = "../" + module_name
+        doclist = glob.glob(os.path.join(module_path,"doc/*.rst"))
+        for doc in doclist:
+            self.parse_rst_file(module_name, doc)
+            
+    def parse_section_safe(self, module_name, section_name, file_name, lineno, lines):
+        try:
+            self.parse_section(module_name, section_name, file_name, lineno, lines)
+        except AssertionError, args:
+            if show_errors:
+                print >> sys.stderr, "RST parser error: assertion in \"%s\"  File: %s (line %s)" % (section_name, file_name, lineno)
+                print >> sys.stderr, "    Details: %s" % args
+
+    def parse_section(self, module_name, section_name, file_name, lineno, lines):
+        self.sections_total += 1
+        # skip sections having whitespace in name
+        if section_name.find(" ") >= 0 and section_name.find("::operator") < 0:
+            if show_errors:
+                print "SKIPPED: \"%s\" File: %s (line %s)" % (section_name, file_name, lineno)
+            self.sections_skipped += 1
+            return
+
+        func = {}
+        func["name"] = section_name
+        func["file"] = file_name
+        func["line"] = lineno
+        func["module"] = module_name
+
+        # parse section name
+        section_name = self.parse_namespace(func, section_name)
+        class_separator_idx = section_name.find("::")
+        if class_separator_idx > 0:
+            func["class"] = section_name[:class_separator_idx]
+            func["method"] = section_name[class_separator_idx+2:]
+        else:
+            func["method"] = section_name
+
+        capturing_seealso = False
+        skip_code_lines = False
+        expected_brief = True
+        fdecl = DeclarationParser()
+        pdecl = ParamParser()
+
+        for l in lines:
+            # read tail of function/method declaration if needed
+            if not fdecl.isready():
+                fdecl.append(ll)
+                if fdecl.isready():
+                    self.add_new_fdecl(func, fdecl)
+                continue
+
+            # continue capture seealso
+            if capturing_seealso:
+                if not l or l.startswith(" "):
+                    seealso = func.get("seealso",[])
+                    seealso.extend(l.split(","))
+                    func["seealso"] = seealso
+                    continue
+                else:
+                    capturing_seealso = False
+
+            ll = l.strip()
+            if ll == "..":
+                expected_brief = False
+                skip_code_lines = False
+                continue
+
+            # skip lines if line-skipping mode is activated
+            if skip_code_lines:
+                if not l or l.startswith(" "):
+                    continue
+                else:
+                    skip_code_lines = False
+                    
+            if ll.startswith(".. code-block::") or ll.startswith(".. image::"):
+                skip_code_lines = True
+                continue
+                
+            # todo: parse structure members; skip them for now
+            if ll.startswith(".. ocv:member::"):
+                skip_code_lines = True
+                continue
+                
+            #ignore references (todo: collect them)
+            if l.startswith(".. ["):
+                continue
+
+            if ll.startswith(".. "):
+                expected_brief = False
+            elif ll.endswith("::"):
+                # turn on line-skipping mode for code fragments
+                skip_code_lines = True
+                ll = ll[:len(ll)-2]
+                
+            # continue param parsing (process params after processing .. at the beginning of the line and :: at the end)
+            if pdecl.active:
+                pdecl.append(l)
+                if pdecl.active:
+                    continue
+                else:
+                    self.add_new_pdecl(func, pdecl)
+                    # do not continue - current line can contain next parameter definition
+
+            # parse ".. seealso::" blocks
+            if ll.startswith(".. seealso::"):
+                if ll.endswith(".. seealso::"):
+                    capturing_seealso = True
+                else:
+                    seealso = func.get("seealso",[])
+                    seealso.extend(ll[ll.find("::")+2:].split(","))
+                    func["seealso"] = seealso
+                continue
+
+            # skip ".. index::"
+            if ll.startswith(".. index::"):
+                continue
+
+            # parse class & struct definitions
+            if ll.startswith(".. ocv:class::"):
+                func["class"] = ll[ll.find("::")+2:].strip()
+                if "method" in func:
+                    del func["method"]
+                func["isclass"] = True
+                expected_brief = True
+                continue
+
+            if ll.startswith(".. ocv:struct::"):
+                func["class"] = ll[ll.find("::")+2:].strip()
+                if "method" in func:
+                    del func["method"]
+                func["isstruct"] = True
+                expected_brief = True
+                continue
+
+            # parse function/method definitions
+            if fdecl.hasDeclaration(ll):
+                fdecl = DeclarationParser(ll)
+                if fdecl.isready():
+                    self.add_new_fdecl(func, fdecl)
+                continue
+
+            # parse parameters
+            if pdecl.hasDeclaration(l):
+                pdecl = ParamParser(l)
+                continue
+
+            # record brief description
+            if expected_brief:
+                func["brief"] = func.get("brief", "") + "\n" + ll
+                if skip_code_lines:
+                    expected_brief = False # force end brief if code block begins
+                continue
+
+            # record other lines as long description
+            func["long"] = func.get("long", "") + "\n" + ll
+            if skip_code_lines:
+                func["long"] = func.get("long", "") + "\n"
+        # endfor l in lines
+        
+        if fdecl.balance != 0:
+            if show_errors:
+                print >> sys.stderr, "RST parser error: invalid parentheses balance in \"%s\" File: %s (line %s)" % (section_name, file_name, lineno)
+            return
+
+        # save last parameter if needed
+        if pdecl.active:
+            self.add_new_pdecl(func, pdecl)
+
+        # add definition to list
+        func = self.normalize(func)
+        if self.validate(func):
+            self.definitions[func["name"]] = func
+            self.sections_parsed += 1
+            if verbose:
+                self.print_info(func)
+        elif func:
+            if show_errors:
+                self.print_info(func, True, sys.stderr)
+
+    def parse_rst_file(self, module_name, doc):
+        doc = os.path.abspath(doc)
+        lineno = 0
+        whitespace_warnings = 0
+        max_whitespace_warnings = 10
+      
+        lines = []
+        flineno = 0
+        fname = ""
+        prev_line = None
+
+        df = open(doc, "rt")
+        for l in df.readlines():
+            lineno += 1
+            # handle tabs
+            if l.find("\t") >= 0:
+                whitespace_warnings += 1
+                if whitespace_warnings <= max_whitespace_warnings and show_warnings:
+                    print >> sys.stderr, "RST parser warning: tab symbol instead of space is used at file %s (line %s)" % (doc, lineno)
+                l = l.replace("\t", "    ")
+                
+            # handle first line
+            if prev_line == None:
+                prev_line = l.rstrip()
+                continue
+
+            ll = l.rstrip()
+            if len(prev_line) > 0 and len(ll) >= len(prev_line) and ll == "-" * len(ll):
+                # new function candidate
+                if len(lines) > 1:
+                    self.parse_section_safe(module_name, fname, doc, flineno, lines[:len(lines)-1])
+                lines = []
+                flineno = lineno-1
+                fname = prev_line.strip()
+            elif flineno > 0:
+                lines.append(ll)               
+            prev_line = ll
+        df.close()
+
+        # don't forget about the last function section in file!!!
+        if len(lines) > 1:
+            self.parse_section_safe(module_name, fname, doc, flineno, lines)
+
+    def parse_namespace(self, func, section_name):
+        known_namespaces = ["cv", "gpu", "flann"]
+        l = section_name.strip()
+        for namespace in known_namespaces:
+            if l.startswith(namespace + "::"):
+                func["namespace"] = namespace
+                return l[len(namespace)+2:]
+        return section_name
+
+    def add_new_fdecl(self, func, decl):
+        decls =  func.get("decls",[])
+        if (decl.lang == "C++" or decl.lang == "C"):
+            rst_decl = self.cpp_parser.parse_func_decl_no_wrap(decl.fdecl)
+            decls.append( (decl.lang, decl.fdecl, rst_decl) )
+        else:
+            decls.append( (decl.lang, decl.fdecl) )
+        func["decls"] = decls
+
+    def add_new_pdecl(self, func, decl):
+        params =  func.get("params",{})
+        if decl.name in params:
+            if show_errors:
+                print >> sys.stderr, "RST parser error: redefinition of parameter \"%s\" in \"%s\" File: %s (line %s)" \
+                    % (decl.name, func["name"], func["file"], func["line"])
+        else:
+            params[decl.name] = decl.comment
+            func["params"] = params
+
+    def print_info(self, func, skipped=False, out = sys.stdout):
+        print >> out
+        if skipped:
+            print >> out, "SKIPPED DEFINITION:"
+        print >> out, "name:      %s" % (func.get("name","~empty~"))
+        print >> out, "file:      %s (line %s)" % (func.get("file","~empty~"), func.get("line","~empty~"))
+        print >> out, "is class:  %s" % func.get("isclass",False)
+        print >> out, "is struct: %s" % func.get("isstruct",False)
+        print >> out, "module:    %s" % func.get("module","~unknown~")
+        print >> out, "namespace: %s" % func.get("namespace", "~empty~")
+        print >> out, "class:     %s" % (func.get("class","~empty~"))
+        print >> out, "method:    %s" % (func.get("method","~empty~"))
+        print >> out, "brief:     %s" % (func.get("brief","~empty~"))
+        if "decls" in func:
+            print >> out, "declarations:"
+            for d in func["decls"]:
+               print >> out, "     %7s: %s" % (d[0], re.sub(r"[ ]+", " ", d[1]))
+        if "seealso" in func:
+            print >> out, "seealso:  ", func["seealso"]
+        if "params" in func:
+            print >> out, "parameters:"
+            for name, comment in func["params"].items():
+                print >> out, "%23s:   %s" % (name, comment)
+        print >> out, "long:      %s" % (func.get("long","~empty~"))
+        print >> out
+
+    def validate(self, func):
+        if func.get("decls",None) is None:
+            if not func.get("isclass",False) and not func.get("isstruct",False):
+                return False
+        if func["name"] in self.definitions:
+            if show_errors:
+                print >> sys.stderr, "RST parser error: \"%s\" from file: %s (line %s) is already documented in file: %s (line %s)" \
+                    % (func["name"], func["file"], func["line"], self.definitions[func["name"]]["file"], self.definitions[func["name"]]["line"])
+            return False
+        return self.validateParams(func)
+
+    def validateParams(self, func):
+        documentedParams = func.get("params",{}).keys()
+        params = []
+       	
+        for decl in func.get("decls", []):
+            if len(decl) > 2:
+                args = decl[2][3] # decl[2] -> [ funcname, return_ctype, [modifiers], [args] ]
+                for arg in args:
+                    # arg -> [ ctype, name, def val, [mod], argno ]
+                    if arg[0] != "...":
+                        params.append(arg[1])
+        params = list(set(params))#unique
+
+        # 1. all params are documented
+        for p in params:
+            if p not in documentedParams and show_warnings:
+                print >> sys.stderr, "RST parser warning: parameter \"%s\" of \"%s\" is undocumented. File: %s (line %s)" % (p, func["name"], func["file"], func["line"])
+
+        # 2. only real params are documented
+        for p in documentedParams:
+            if p not in params and show_warnings:
+                print >> sys.stderr, "RST parser warning: unexisting parameter \"%s\" of \"%s\" is documented. File: %s (line %s)" % (p, func["name"], func["file"], func["line"])
+        return True
+
+    def normalize(self, func):
+        if not func:
+            return func
+        func["name"] = self.normalizeText(func["name"])
+        if "method" in func:
+            func["method"] = self.normalizeText(func["method"])
+        if "class" in func:
+            func["class"] = self.normalizeText(func["class"])
+        if "brief" in func:
+            func["brief"] = self.normalizeText(func.get("brief",None))
+            if not func["brief"]:
+                del func["brief"]
+        if "long" in func:
+            func["long"] = self.normalizeText(func.get("long",None))
+            if not func["long"]:
+                del func["long"]
+        if "decls" in func:
+            func["decls"].sort()
+        if "params" in func:
+            params = {}
+            for name, comment in func["params"].items():
+                cmt = self.normalizeText(comment)
+                if cmt:
+                    params[name] = cmt
+            func["params"] = params
+        if "seealso" in func:
+            seealso = []
+            for see in func["seealso"]:
+                item = self.normalizeText(see.rstrip(".")).strip("\"")
+                if item and (item.find(" ") < 0 or item.find("::operator") > 0):
+                    seealso.append(item)
+            func["seealso"] = list(set(seealso))
+            if not func["seealso"]:
+                del func["seealso"]
+
+        # special case for old C functions - section name should omit "cv" prefix
+        if not func.get("isclass",False) and not func.get("isstruct",False):
+            self.fixOldCFunctionName(func)
+        return func
+
+    def fixOldCFunctionName(self, func):
+        if not "decls" in func: 
+            return
+        fname = None
+        for decl in func["decls"]:
+            if decl[0] != "C" and decl[0] != "Python1":
+                return
+            if decl[0] == "C":
+                fname = decl[2][0]
+        if fname is None:
+            return
+
+        fname = fname.replace(".", "::")
+        if fname.startswith("cv::cv"):
+            if fname[6:] == func.get("name", ""):
+                func["name"] = fname[4:]
+                func["method"] = fname[4:]
+            elif show_warnings:
+                print >> sys.stderr, "RST parser warning: invalid definition of old C function \"%s\" - section name is \"%s\" instead of \"%s\". File: %s (line %s)" % (fname, func["name"], fname[6:], func["file"], func["line"])
+                #self.print_info(func)
+                
+    def normalizeText(self, s):
+        if s is None:
+            return s
+        s = re.sub(r"\.\. math::[ ]*\n+(.*?)(\n[ ]*\n|$)", mathReplace2, s)
+        s = re.sub(r":math:`([^`]+?)`", mathReplace, s)
+        s = re.sub(r" *:sup:", "^", s)
+        
+        s = s.replace(":ocv:class:", "")
+        s = s.replace(":ocv:struct:", "")
+        s = s.replace(":ocv:func:", "")
+        s = s.replace(":ocv:cfunc:","")
+        s = s.replace(":c:type:", "")
+        s = s.replace(":c:func:", "")
+        s = s.replace(":ref:", "")
+        s = s.replace(":math:", "")
+        s = s.replace(":func:", "")
+
+        s = s.replace("]_", "]")
+        s = s.replace(".. note::", "Note:")
+        s = s.replace(".. table::", "")
+        s = s.replace(".. ocv:function::", "")
+        s = s.replace(".. ocv:cfunction::", "")
+
+        # remove ".. identifier:" lines
+        s = re.sub(r"(^|\n)\.\. [a-zA-Z_0-9]+(::[a-zA-Z_0-9]+)?:(\n|$)", "\n ", s)
+        # unwrap urls
+        s = re.sub(r"`([^`<]+ )<(https?://[^>]+)>`_", "\\1(\\2)", s)
+        # remove tailing ::
+        s = re.sub(r"::(\n|$)", "\\1", s)
+            
+        # normalize line endings
+        s = re.sub(r"\r\n", "\n", s)
+        # remove extra line breaks before/after _ or ,
+        s = re.sub(r"\n[ ]*([_,])\n", r"\1 ", s)
+        # remove extra line breaks after `
+        #s = re.sub(r"`\n", "` ", s)
+        # remove extra space after ( and before .,)
+        s = re.sub(r"\([\n ]+", "(", s)
+        s = re.sub(r"[\n ]+(\.|,|\))", "\\1", s)
+        # remove extra line breaks after ".. note::"
+        s = re.sub(r"\.\. note::\n+", ".. note:: ", s)
+        # remove extra line breaks before *
+        s = re.sub(r"\n+\*", "\n*", s)
+        # remove extra line breaks after *
+        s = re.sub(r"\n\*\n+", "\n* ", s)
+        # remove extra line breaks before #.
+        s = re.sub(r"\n+#\.", "\n#.", s)
+        # remove extra line breaks after #.
+        s = re.sub(r"\n#\.\n+", "\n#. ", s)
+        # remove extra line breaks before `
+        #s = re.sub(r"\n[ ]*`", " `", s)
+        # remove trailing whitespaces
+        s = re.sub(r"[ ]+$", "", s)
+        # remove .. for references
+        #s = re.sub(r"\.\. \[", "[", s)
+        # unescape
+        s = re.sub(r"\\(.)", "\\1", s)
+        
+        # remove whitespace before .
+        s = re.sub(r"[ ]+\.", ".", s)
+        # remove tailing whitespace
+        s = re.sub(r" +(\n|$)", "\\1", s)
+        # remove leading whitespace
+        s = re.sub(r"(^|\n) +", "\\1", s)
+        # compress line breaks
+        s = re.sub(r"\n\n+", "\n\n", s)
+        # remove other newlines
+        s = re.sub(r"([^.\n\\=])\n([^*#\n]|\*[^ ])", "\\1 \\2", s)
+        # compress whitespace
+        s = re.sub(r" +", " ", s)
+
+        # restore math
+        s = re.sub(r" *<BR> *","\n", s)
+
+        # remove extra space before .
+        s = re.sub(r"[\n ]+\.", ".", s)
+
+        s = s.replace("**", "")
+        s = s.replace("``", "\"")
+        s = s.replace("`", "\"")
+        s = s.replace("\"\"", "\"")
+
+        s = s.strip()
+        return s
+        
+    def printSummary(self):
+        print
+        print "RST Parser Summary:"
+        print "  Total sections:   %s" % self.sections_total
+        print "  Skipped sections: %s" % self.sections_skipped
+        print "  Parsed  sections: %s" % self.sections_parsed
+        print "  Invalid sections: %s" % (self.sections_total - self.sections_parsed - self.sections_skipped)
+
+        # statistic by language
+        stat = {}
+        classes = 0
+        structs = 0
+        for name, d in self.definitions.items():
+           if d.get("isclass", False):
+               classes += 1
+           elif d.get("isstruct", False):
+               structs += 1
+           else:
+               for decl in d.get("decls",[]):
+                   stat[decl[0]] = stat.get(decl[0],0) + 1
+
+        print
+        print "  classes documented:           %s" % classes
+        print "  structs documented:           %s" % structs
+        for lang in sorted(stat.items()):
+            print "  %7s functions documented: %s" % lang
+        print
+
+def mathReplace2(match):
+    m = mathReplace(match)
+    #print "%s   ===>   %s" % (match.group(0), m)
+    return "\n\n"+m+"<BR><BR>"
+
+def hdotsforReplace(match):
+    return '...  '*int(match.group(1))
+
+def matrixReplace(match):
+    m = match.group(2)
+    m = re.sub(r" *& *", "   ", m)
+    return m
+        
+def mathReplace(match):
+    m = match.group(1)
+
+    m = m.replace("\n", "<BR>")
+    m = re.sub(r"\\text(tt|rm)?{(.*?)}", "\\2", m)
+    m = re.sub(r"\\mbox{(.*?)}", "\\1", m)
+    m = re.sub(r"\\mathrm{(.*?)}", "\\1", m)
+    m = re.sub(r"\\vecthree{(.*?)}{(.*?)}{(.*?)}", "[\\1 \\2 \\3]", m)
+    m = re.sub(r"\\bar{(.*?)}", "\\1`", m)
+    m = re.sub(r"\\sqrt\[(\d)*\]{(.*?)}", "sqrt\\1(\\2)", m)
+    m = re.sub(r"\\sqrt{(.*?)}", "sqrt(\\1)", m)
+    m = re.sub(r"\\frac{(.*?)}{(.*?)}", "(\\1)/(\\2)", m)
+    m = re.sub(r"\\fork{(.*?)}{(.*?)}{(.*?)}{(.*?)}", "\\1 \\2; \\3 \\4", m)
+    m = re.sub(r"\\forkthree{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}", "\\1 \\2; \\3 \\4; \\5 \\6", m)
+    m = re.sub(r"\\stackrel{(.*?)}{(.*?)}", "\\1 \\2", m)
+    m = re.sub(r"\\sum _{(.*?)}", "sum{by: \\1}", m)
+
+    m = re.sub(r" +", " ", m)
+    m = re.sub(r"\\begin{(?P<gtype>array|bmatrix)}(?:{[\|lcr\. ]+})? *(.*?)\\end{(?P=gtype)}", matrixReplace, m)
+    m = re.sub(r"\\hdotsfor{(\d+)}", hdotsforReplace, m)
+    m = re.sub(r"\\vecthreethree{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}{(.*?)}", "<BR>|\\1 \\2 \\3|<BR>|\\4 \\5 \\6|<BR>|\\7 \\8 \\9|<BR>", m)
+    
+    m = re.sub(r"\\left[ ]*\\lfloor[ ]*", "[", m)
+    m = re.sub(r"[ ]*\\right[ ]*\\rfloor", "]", m)
+    m = re.sub(r"\\left[ ]*\([ ]*", "(", m)
+    m = re.sub(r"[ ]*\\right[ ]*\)", ")", m)
+    m = re.sub(r"([^\\])\$", "\\1", m)
+
+    m = m.replace("\\times", "x")
+    m = m.replace("\\pm", "+-")
+    m = m.replace("\\cdot", "*")
+    m = m.replace("\\sim", "~")
+    m = m.replace("\\leftarrow", "<-")
+    m = m.replace("\\rightarrow", "->")
+    m = m.replace("\\leftrightarrow", "<->")
+    m = re.sub(r" *\\neg *", " !", m)
+    m = re.sub(r" *\\neq? *", " != ", m)
+    m = re.sub(r" *\\geq? *", " >= ", m)
+    m = re.sub(r" *\\leq? *", " <= ", m)
+    m = re.sub(r" *\\vee *", " V ", m)
+    m = re.sub(r" *\\oplus *", " (+) ", m)
+    m = re.sub(r" *\\mod *", " mod ", m)
+    m = re.sub(r"( *)\\partial *", "\\1d", m)
+
+    m = re.sub(r"( *)\\quad *", "\\1 ", m)
+    m = m.replace("\\,", " ")
+    m = m.replace("\\:", "  ")
+    m = m.replace("\\;", "   ")
+    m = m.replace("\\!", "")
+
+    m = m.replace("\\\\", "<BR>")
+    m = m.replace("\\wedge", "/\\\\")
+    m = re.sub(r"\\(.)", "\\1", m)
+
+    m = re.sub(r"\([ ]+", "(", m)
+    m = re.sub(r"[ ]+(\.|,|\))(<BR>| |$)", "\\1\\2", m)
+    m = re.sub(r" +\|[ ]+([a-zA-Z0-9_(])", " |\\1", m)
+    m = re.sub(r"([a-zA-Z0-9_)}])[ ]+(\(|\|)", "\\1\\2", m)
+
+    m = re.sub(r"{\((-?[a-zA-Z0-9_]+)\)}", "\\1", m)
+    m = re.sub(r"{(-?[a-zA-Z0-9_]+)}", "(\\1)", m)
+    m = re.sub(r"\(([0-9]+)\)", "\\1", m)
+    m = m.replace("{", "(")
+    m = m.replace("}", ")")
+
+    #print "%s   ===>   %s" % (match.group(0), m)
+    return m
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print "Usage:\n", os.path.basename(sys.argv[0]), " <module path>"
+        exit(0)
+        
+    if len(sys.argv) >= 3:
+        if sys.argv[2].lower() == "verbose":
+            verbose = True
+
+    rst_parser_dir  = os.path.dirname(os.path.abspath(sys.argv[0]))
+    hdr_parser_path = os.path.join(rst_parser_dir, "../python/src2")
+
+    sys.path.append(hdr_parser_path)
+    import hdr_parser
+
+    module = sys.argv[1]
+
+    if module != "all" and not os.path.isdir(os.path.join(rst_parser_dir, "../" + module)):
+        print "Module \"" + module + "\" could not be found."
+        exit(1)
+
+    parser = RstParser(hdr_parser.CppHeaderParser())
+    
+    if module == "all":
+        for m in allmodules:
+            parser.parse(m, os.path.join(rst_parser_dir, "../" + m))
+    else:
+        parser.parse(module, os.path.join(rst_parser_dir, "../" + module))
+
+    # summary
+    parser.printSummary()
diff --git a/modules/java/src/cpp/Mat.cpp b/modules/java/src/cpp/Mat.cpp
new file mode 100644
index 0000000000..98b7ed9df7
--- /dev/null
+++ b/modules/java/src/cpp/Mat.cpp
@@ -0,0 +1,2205 @@
+#include <jni.h>
+
+#include "converters.h"
+
+#ifdef DEBUG
+#include <android/log.h>
+#define MODULE_LOG_TAG "OpenCV.core.Mat"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
+#else //DEBUG
+#define LOGD(...)
+#endif //DEBUG
+
+#include "opencv2/core/core.hpp"
+
+using namespace cv;
+
+extern "C" {
+
+
+//
+//   MatXXX::MatXXX()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__
+  (JNIEnv* env, jclass cls)
+{
+    LOGD("Mat::n_1Mat__()");
+    return (jlong) new cv::Mat();
+}
+
+
+
+//
+//   Mat::Mat(int rows, int cols, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__III
+  (JNIEnv* env, jclass cls, jint rows, jint cols, jint type)
+{
+    try {
+        LOGD("Mat::n_1Mat__III()");
+        
+        Mat* _retval_ = new Mat( rows, cols, type );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__III() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__III() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__III()}");
+        return 0;
+    }
+}
+
+
+
+//
+//   Mat::Mat(Size size, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__DDI
+  (JNIEnv* env, jclass cls, jdouble size_width, jdouble size_height, jint type)
+{
+    try {
+        LOGD("Mat::n_1Mat__DDI()");
+        Size size((int)size_width, (int)size_height);
+        Mat* _retval_ = new Mat( size, type );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__DDI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__DDI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__DDI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//   Mat::Mat(int rows, int cols, int type, Scalar s)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__IIIDDDD
+  (JNIEnv* env, jclass cls, jint rows, jint cols, jint type, jdouble s_val0, jdouble s_val1, jdouble s_val2, jdouble s_val3)
+{
+    try {
+        LOGD("Mat::n_1Mat__IIIDDDD()");
+        Scalar s(s_val0, s_val1, s_val2, s_val3);
+        Mat* _retval_ = new Mat( rows, cols, type, s );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__IIIDDDD() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__IIIDDDD() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__IIIDDDD()}");
+        return 0;
+    }
+}
+
+
+
+//
+//   Mat::Mat(Size size, int type, Scalar s)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__DDIDDDD
+  (JNIEnv* env, jclass cls, jdouble size_width, jdouble size_height, jint type, jdouble s_val0, jdouble s_val1, jdouble s_val2, jdouble s_val3)
+{
+    try {
+        LOGD("Mat::n_1Mat__DDIDDDD()");
+        Size size((int)size_width, (int)size_height);
+        Scalar s(s_val0, s_val1, s_val2, s_val3);
+        Mat* _retval_ = new Mat( size, type, s );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__DDIDDDD() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__DDIDDDD() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__DDIDDDD()}");
+        return 0;
+    }
+}
+
+
+
+//
+//   Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__JIIII
+  (JNIEnv* env, jclass cls, jlong m_nativeObj, jint rowRange_start, jint rowRange_end, jint colRange_start, jint colRange_end)
+{
+    try {
+        LOGD("Mat::n_1Mat__JIIII()");
+        Range rowRange(rowRange_start, rowRange_end);
+        Range colRange(colRange_start, colRange_end);
+        Mat* _retval_ = new Mat( (*(Mat*)m_nativeObj), rowRange, colRange );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__JIIII() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__JIIII() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__JIIII()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1Mat__JII
+  (JNIEnv* env, jclass cls, jlong m_nativeObj, jint rowRange_start, jint rowRange_end)
+{
+    try {
+        LOGD("Mat::n_1Mat__JII()");
+        Range rowRange(rowRange_start, rowRange_end);
+        Mat* _retval_ = new Mat( (*(Mat*)m_nativeObj), rowRange );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1Mat__JII() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1Mat__JII() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1Mat__JII()}");
+        return 0;
+    }
+}
+
+
+//
+//  Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1adjustROI
+  (JNIEnv* env, jclass cls, jlong self, jint dtop, jint dbottom, jint dleft, jint dright)
+{
+    try {
+        LOGD("Mat::n_1adjustROI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->adjustROI( dtop, dbottom, dleft, dright );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1adjustROI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1adjustROI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1adjustROI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void Mat::assignTo(Mat m, int type = -1)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1assignTo__JJI
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jint type)
+{
+    try {
+        LOGD("Mat::n_1assignTo__JJI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        me->assignTo( (*(Mat*)m_nativeObj), type );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1assignTo__JJI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1assignTo__JJI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1assignTo__JJI()}");
+        return;
+    }
+}
+
+
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1assignTo__JJ
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1assignTo__JJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        me->assignTo( (*(Mat*)m_nativeObj) );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1assignTo__JJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1assignTo__JJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1assignTo__JJ()}");
+        return;
+    }
+}
+
+
+
+//
+//  int Mat::channels()
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1channels
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1channels()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->channels(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1channels() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1channels() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1channels()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  int Mat::checkVector(int elemChannels, int depth = -1, bool requireContinuous = true)
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1checkVector__JIIZ
+  (JNIEnv* env, jclass cls, jlong self, jint elemChannels, jint depth, jboolean requireContinuous)
+{
+    try {
+        LOGD("Mat::n_1checkVector__JIIZ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->checkVector( elemChannels, depth, requireContinuous );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1checkVector__JIIZ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1checkVector__JIIZ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1checkVector__JIIZ()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1checkVector__JII
+  (JNIEnv* env, jclass cls, jlong self, jint elemChannels, jint depth)
+{
+    try {
+        LOGD("Mat::n_1checkVector__JII()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->checkVector( elemChannels, depth );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1checkVector__JII() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1checkVector__JII() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1checkVector__JII()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1checkVector__JI
+  (JNIEnv* env, jclass cls, jlong self, jint elemChannels)
+{
+    try {
+        LOGD("Mat::n_1checkVector__JI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->checkVector( elemChannels );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1checkVector__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1checkVector__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1checkVector__JI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::clone()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1clone
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1clone()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->clone(  );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1clone() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1clone() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1clone()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::col(int x)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1col
+  (JNIEnv* env, jclass cls, jlong self, jint x)
+{
+    try {
+        LOGD("Mat::n_1col()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->col( x );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1col() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1col() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1col()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::colRange(int startcol, int endcol)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1colRange
+  (JNIEnv* env, jclass cls, jlong self, jint startcol, jint endcol)
+{
+    try {
+        LOGD("Mat::n_1colRange()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->colRange( startcol, endcol );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1colRange() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1colRange() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1colRange()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  int Mat::cols()
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1cols
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1cols()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->cols;
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1cols() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1cols() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1cols()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta = 0)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1convertTo__JJIDD
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jint rtype, jdouble alpha, jdouble beta)
+{
+    try {
+        LOGD("Mat::n_1convertTo__JJIDD()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        me->convertTo( m, rtype, alpha, beta );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1convertTo__JJIDD() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1convertTo__JJIDD() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1convertTo__JJIDD()}");
+        return;
+    }
+}
+
+
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1convertTo__JJID
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jint rtype, jdouble alpha)
+{
+    try {
+        LOGD("Mat::n_1convertTo__JJID()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        me->convertTo( m, rtype, alpha );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1convertTo__JJID() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1convertTo__JJID() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1convertTo__JJID()}");
+        return;
+    }
+}
+
+
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1convertTo__JJI
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jint rtype)
+{
+    try {
+        LOGD("Mat::n_1convertTo__JJI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        me->convertTo( m, rtype );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1convertTo__JJI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1convertTo__JJI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1convertTo__JJI()}");
+        return;
+    }
+}
+
+
+
+//
+//  void Mat::copyTo(Mat& m)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1copyTo__JJ
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1copyTo__JJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        me->copyTo( m );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1copyTo__JJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1copyTo__JJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1copyTo__JJ()}");
+        return;
+    }
+}
+
+
+
+//
+//  void Mat::copyTo(Mat& m, Mat mask)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1copyTo__JJJ
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jlong mask_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1copyTo__JJJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        Mat& mask = *((Mat*)mask_nativeObj);
+        me->copyTo( m, mask );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1copyTo__JJJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1copyTo__JJJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1copyTo__JJJ()}");
+        return;
+    }
+}
+
+
+
+//
+//  void Mat::create(int rows, int cols, int type)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1create__JIII
+  (JNIEnv* env, jclass cls, jlong self, jint rows, jint cols, jint type)
+{
+    try {
+        LOGD("Mat::n_1create__JIII()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        me->create( rows, cols, type );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1create__JIII() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1create__JIII() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1create__JIII()}");
+        return;
+    }
+}
+
+
+
+//
+//  void Mat::create(Size size, int type)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1create__JDDI
+  (JNIEnv* env, jclass cls, jlong self, jdouble size_width, jdouble size_height, jint type)
+{
+    try {
+        LOGD("Mat::n_1create__JDDI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Size size((int)size_width, (int)size_height);
+        me->create( size, type );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1create__JDDI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1create__JDDI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1create__JDDI()}");
+        return;
+    }
+}
+
+
+
+//
+//  Mat Mat::cross(Mat m)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1cross
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1cross()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        Mat _retval_ = me->cross( m );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1cross() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1cross() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1cross()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  long Mat::dataAddr()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1dataAddr
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    LOGD("Mat::n_1dataAddr()");
+    Mat* me = (Mat*) self; //TODO: check for NULL
+    return (jlong) me->data;
+}
+
+
+
+//
+//  int Mat::depth()
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1depth
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1depth()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->depth(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1depth() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1depth() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1depth()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::diag(int d = 0)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1diag__JI
+  (JNIEnv* env, jclass cls, jlong self, jint d)
+{
+    try {
+        LOGD("Mat::n_1diag__JI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->diag( d );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1diag__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1diag__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1diag__JI()}");
+        return 0;
+    }
+}
+
+
+
+
+//
+// static Mat Mat::diag(Mat d)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1diag__J
+  (JNIEnv* env, jclass cls, jlong d_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1diag__J()");
+        
+        Mat _retval_ = Mat::diag( (*(Mat*)d_nativeObj) );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1diag__J() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1diag__J() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1diag__J()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  double Mat::dot(Mat m)
+//
+
+
+JNIEXPORT jdouble JNICALL Java_org_opencv_core_Mat_n_1dot
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1dot()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        double _retval_ = me->dot( m );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1dot() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1dot() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1dot()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  size_t Mat::elemSize()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1elemSize
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1elemSize()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        size_t _retval_ = me->elemSize(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1elemSize() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1elemSize() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1elemSize()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  size_t Mat::elemSize1()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1elemSize1
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1elemSize1()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        size_t _retval_ = me->elemSize1(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1elemSize1() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1elemSize1() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1elemSize1()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool Mat::empty()
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_core_Mat_n_1empty
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1empty()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        bool _retval_ = me->empty(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1empty() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1empty() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1empty()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::eye(int rows, int cols, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1eye__III
+  (JNIEnv* env, jclass cls, jint rows, jint cols, jint type)
+{
+    try {
+        LOGD("Mat::n_1eye__III()");
+        
+        Mat _retval_ = Mat::eye( rows, cols, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1eye__III() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1eye__III() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1eye__III()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::eye(Size size, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1eye__DDI
+  (JNIEnv* env, jclass cls, jdouble size_width, jdouble size_height, jint type)
+{
+    try {
+        LOGD("Mat::n_1eye__DDI()");
+        Size size((int)size_width, (int)size_height);
+        Mat _retval_ = Mat::eye( size, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1eye__DDI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1eye__DDI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1eye__DDI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::inv(int method = DECOMP_LU)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1inv__JI
+  (JNIEnv* env, jclass cls, jlong self, jint method)
+{
+    try {
+        LOGD("Mat::n_1inv__JI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->inv( method );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1inv__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1inv__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1inv__JI()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1inv__J
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1inv__J()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->inv(  );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1inv__J() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1inv__J() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1inv__J()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool Mat::isContinuous()
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_core_Mat_n_1isContinuous
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1isContinuous()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        bool _retval_ = me->isContinuous(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1isContinuous() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1isContinuous() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1isContinuous()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool Mat::isSubmatrix()
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_core_Mat_n_1isSubmatrix
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1isSubmatrix()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        bool _retval_ = me->isSubmatrix(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1isSubmatrix() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1isSubmatrix() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1isSubmatrix()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void Mat::locateROI(Size wholeSize, Point ofs)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_locateROI_10
+  (JNIEnv* env, jclass cls, jlong self, jdoubleArray wholeSize_out, jdoubleArray ofs_out)
+{
+    try {
+        LOGD("core::locateROI_10()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Size wholeSize;
+        Point ofs;
+        me->locateROI( wholeSize, ofs );
+        jdouble tmp_wholeSize[2] = {wholeSize.width, wholeSize.height}; env->SetDoubleArrayRegion(wholeSize_out, 0, 2, tmp_wholeSize);  jdouble tmp_ofs[2] = {ofs.x, ofs.y}; env->SetDoubleArrayRegion(ofs_out, 0, 2, tmp_ofs);
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::locateROI_10() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::locateROI_10() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::locateROI_10()}");
+        return;
+    }
+}
+
+
+
+//
+//  Mat Mat::mul(Mat m, double scale = 1)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1mul__JJD
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj, jdouble scale)
+{
+    try {
+        LOGD("Mat::n_1mul__JJD()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        Mat _retval_ = me->mul( m, scale );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1mul__JJD() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1mul__JJD() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1mul__JJD()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1mul__JJ
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1mul__JJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& m = *((Mat*)m_nativeObj);
+        Mat _retval_ = me->mul( m );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1mul__JJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1mul__JJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1mul__JJ()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::ones(int rows, int cols, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1ones__III
+  (JNIEnv* env, jclass cls, jint rows, jint cols, jint type)
+{
+    try {
+        LOGD("Mat::n_1ones__III()");
+        
+        Mat _retval_ = Mat::ones( rows, cols, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1ones__III() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1ones__III() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1ones__III()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::ones(Size size, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1ones__DDI
+  (JNIEnv* env, jclass cls, jdouble size_width, jdouble size_height, jint type)
+{
+    try {
+        LOGD("Mat::n_1ones__DDI()");
+        Size size((int)size_width, (int)size_height);
+        Mat _retval_ = Mat::ones( size, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1ones__DDI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1ones__DDI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1ones__DDI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void Mat::push_back(Mat m)
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1push_1back
+  (JNIEnv* env, jclass cls, jlong self, jlong m_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1push_1back()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        me->push_back( (*(Mat*)m_nativeObj) );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1push_1back() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1push_1back() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1push_1back()}");
+        return;
+    }
+}
+
+
+
+//
+//  void Mat::release()
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1release
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1release()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        me->release(  );
+        
+        return;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1release() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+        LOGD("Mat::n_1release() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1release()}");
+        return;
+    }
+}
+
+
+
+//
+//  Mat Mat::reshape(int cn, int rows = 0)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1reshape__JII
+  (JNIEnv* env, jclass cls, jlong self, jint cn, jint rows)
+{
+    try {
+        LOGD("Mat::n_1reshape__JII()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->reshape( cn, rows );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1reshape__JII() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1reshape__JII() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1reshape__JII()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1reshape__JI
+  (JNIEnv* env, jclass cls, jlong self, jint cn)
+{
+    try {
+        LOGD("Mat::n_1reshape__JI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->reshape( cn );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1reshape__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1reshape__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1reshape__JI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::row(int y)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1row
+  (JNIEnv* env, jclass cls, jlong self, jint y)
+{
+    try {
+        LOGD("Mat::n_1row()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->row( y );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1row() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1row() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1row()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::rowRange(int startrow, int endrow)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1rowRange
+  (JNIEnv* env, jclass cls, jlong self, jint startrow, jint endrow)
+{
+    try {
+        LOGD("Mat::n_1rowRange()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->rowRange( startrow, endrow );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1rowRange() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1rowRange() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1rowRange()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  int Mat::rows()
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1rows
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1rows()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->rows;
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1rows() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1rows() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1rows()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::operator =(Scalar s)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1setTo__JDDDD
+  (JNIEnv* env, jclass cls, jlong self, jdouble s_val0, jdouble s_val1, jdouble s_val2, jdouble s_val3)
+{
+    try {
+        LOGD("Mat::n_1setTo__JDDDD()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Scalar s(s_val0, s_val1, s_val2, s_val3);
+        Mat _retval_ = me->operator =( s );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1setTo__JDDDD() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1setTo__JDDDD() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1setTo__JDDDD()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::setTo(Mat value, Mat mask = Mat())
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1setTo__JJJ
+  (JNIEnv* env, jclass cls, jlong self, jlong value_nativeObj, jlong mask_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1setTo__JJJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& value = *((Mat*)value_nativeObj);
+        Mat& mask = *((Mat*)mask_nativeObj);
+        Mat _retval_ = me->setTo( value, mask );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1setTo__JJJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1setTo__JJJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1setTo__JJJ()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1setTo__JJ
+  (JNIEnv* env, jclass cls, jlong self, jlong value_nativeObj)
+{
+    try {
+        LOGD("Mat::n_1setTo__JJ()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat& value = *((Mat*)value_nativeObj);
+        Mat _retval_ = me->setTo( value );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1setTo__JJ() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1setTo__JJ() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1setTo__JJ()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Size Mat::size()
+//
+
+
+JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Mat_n_1size
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1size()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Size _retval_ = me->size(  );
+        jdoubleArray _da_retval_ = env->NewDoubleArray(2);  jdouble _tmp_retval_[2] = {_retval_.width, _retval_.height}; env->SetDoubleArrayRegion(_da_retval_, 0, 2, _tmp_retval_);
+        return _da_retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1size() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1size() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1size()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  size_t Mat::step1(int i = 0)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1step1__JI
+  (JNIEnv* env, jclass cls, jlong self, jint i)
+{
+    try {
+        LOGD("Mat::n_1step1__JI()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        size_t _retval_ = me->step1( i );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1step1__JI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1step1__JI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1step1__JI()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1step1__J
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1step1__J()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        size_t _retval_ = me->step1(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1step1__J() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1step1__J() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1step1__J()}");
+        return 0;
+    }
+}
+
+//
+//  Mat Mat::operator()(Range rowRange, Range colRange)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1submat_1rr
+  (JNIEnv* env, jclass cls, jlong self, jint rowRange_start, jint rowRange_end, jint colRange_start, jint colRange_end)
+{
+    try {
+        LOGD("Mat::n_1submat_1rr()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Range rowRange(rowRange_start, rowRange_end);
+        Range colRange(colRange_start, colRange_end);
+        Mat _retval_ = me->operator()( rowRange, colRange );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1submat_1rr() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1submat_1rr() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1submat_1rr()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::operator()(Rect roi)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1submat
+  (JNIEnv* env, jclass cls, jlong self, jint roi_x, jint roi_y, jint roi_width, jint roi_height)
+{
+    try {
+        LOGD("Mat::n_1submat()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Rect roi(roi_x, roi_y, roi_width, roi_height);
+        Mat _retval_ = me->operator()( roi );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1submat() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1submat() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1submat()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  Mat Mat::t()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1t
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1t()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        Mat _retval_ = me->t(  );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1t() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1t() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1t()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  size_t Mat::total()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1total
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1total()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        size_t _retval_ = me->total(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1total() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1total() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1total()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  int Mat::type()
+//
+
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_n_1type
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+        LOGD("Mat::n_1type()");
+        Mat* me = (Mat*) self; //TODO: check for NULL
+        int _retval_ = me->type(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1type() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1type() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1type()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::zeros(int rows, int cols, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1zeros__III
+  (JNIEnv* env, jclass cls, jint rows, jint cols, jint type)
+{
+    try {
+        LOGD("Mat::n_1zeros__III()");
+        
+        Mat _retval_ = Mat::zeros( rows, cols, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1zeros__III() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1zeros__III() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1zeros__III()}");
+        return 0;
+    }
+}
+
+
+
+//
+// static Mat Mat::zeros(Size size, int type)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_n_1zeros__DDI
+  (JNIEnv* env, jclass cls, jdouble size_width, jdouble size_height, jint type)
+{
+    try {
+        LOGD("Mat::n_1zeros__DDI()");
+        Size size((int)size_width, (int)size_height);
+        Mat _retval_ = Mat::zeros( size, type );
+        
+        return (jlong) new Mat(_retval_);
+    } catch(cv::Exception e) {
+        LOGD("Mat::n_1zeros__DDI() catched cv::Exception: %s", e.what());
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+        LOGD("Mat::n_1zeros__DDI() catched unknown exception (...)");
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1zeros__DDI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  native support for java finalize()
+//  static void Mat::n_delete( __int64 self )
+//
+
+JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1delete
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    delete (Mat*) self;
+}
+
+// unlike other nPut()-s this one (with double[]) should convert input values to correct type
+#define PUT_ITEM(T, R, C) { T*dst = (T*)me->ptr(R, C); for(int ch=0; ch<me->channels() && count>0; count--,ch++,src++,dst++) *dst = cv::saturate_cast<T>(*src); }
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutD
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(!me || !me->data) return 0;  // no native object behind
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+
+    int rest = ((me->rows - row) * me->cols - col) * me->channels();
+    if(count>rest) count = rest;
+    int res = count;
+    double* values = (double*)env->GetPrimitiveArrayCritical(vals, 0);
+    double* src = values;
+    int r, c;
+    for(c=col; c<me->cols && count>0; c++)
+    {
+        switch(me->depth()) {
+            case CV_8U:  PUT_ITEM(uchar,  row, c); break;
+            case CV_8S:  PUT_ITEM(schar,  row, c); break;
+            case CV_16U: PUT_ITEM(ushort, row, c); break;
+            case CV_16S: PUT_ITEM(short,  row, c); break;
+            case CV_32S: PUT_ITEM(int,    row, c); break;
+            case CV_32F: PUT_ITEM(float,  row, c); break;
+            case CV_64F: PUT_ITEM(double, row, c); break;
+        }
+    }
+
+    for(r=row+1; r<me->rows && count>0; r++)
+        for(c=0; c<me->cols && count>0; c++)
+        {
+            switch(me->depth()) {
+                case CV_8U:  PUT_ITEM(uchar,  r, c); break;
+                case CV_8S:  PUT_ITEM(schar,  r, c); break;
+                case CV_16U: PUT_ITEM(ushort, r, c); break;
+                case CV_16S: PUT_ITEM(short,  r, c); break;
+                case CV_32S: PUT_ITEM(int,    r, c); break;
+                case CV_32F: PUT_ITEM(float,  r, c); break;
+                case CV_64F: PUT_ITEM(double, r, c); break;
+            }
+        }
+
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+
+} // extern "C"
+
+template<typename T> static int mat_put(cv::Mat* m, int row, int col, int count, char* buff)
+{
+    if(! m) return 0;
+    if(! buff) return 0;
+
+    count *= sizeof(T);
+    int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);
+    if(count>rest) count = rest;
+    int res = count;
+
+    if( m->isContinuous() )
+    {
+        memcpy(m->ptr(row, col), buff, count);
+    } else {
+        // row by row
+        int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row
+        if(count<num) num = count;
+        uchar* data = m->ptr(row++, col);
+        while(count>0){
+            memcpy(data, buff, num);
+            count -= num;
+            buff += num;
+            num = m->cols * m->channels() * sizeof(T);
+            if(count<num) num = count;
+            data = m->ptr(row++, 0);
+        }
+    }
+    return res;
+}
+
+
+extern "C" {
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutB
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_put<char>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutS
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_put<short>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutI
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_32S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_put<int>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nPutF
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_32F) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_put<float>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+
+} // extern "C"
+
+template<typename T> int mat_get(cv::Mat* m, int row, int col, int count, char* buff)
+{
+    if(! m) return 0;
+    if(! buff) return 0;
+
+    count *= sizeof(T);
+    int rest = ((m->rows - row) * m->cols - col) * m->channels() * sizeof(T);
+    if(count>rest) count = rest;
+    int res = count;
+
+    if( m->isContinuous() )
+    {
+        memcpy(buff, m->ptr(row, col), count);
+    } else {
+        // row by row
+        int num = (m->cols - col - 1) * m->channels() * sizeof(T); // 1st partial row
+        if(count<num) num = count;
+        uchar* data = m->ptr(row++, col);
+        while(count>0){//TODO: recheck this cycle for the case col!=0
+            memcpy(buff, data, num);
+            count -= num;
+            buff += num;
+            num = m->cols * m->channels() * sizeof(T);
+            if(count<num) num = count;
+            data = m->ptr(row++, 0);
+        }
+    }
+    return res;
+}
+
+extern "C" {
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetB
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jbyteArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_8U && me->depth() != CV_8S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_get<char>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetS
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jshortArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_16U && me->depth() != CV_16S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_get<short>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetI
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jintArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_32S) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_get<int>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetF
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jfloatArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_32F) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_get<float>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jint JNICALL Java_org_opencv_core_Mat_nGetD
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count, jdoubleArray vals)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->depth() != CV_64F) return 0; // incompatible type
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+    
+    char* values = (char*)env->GetPrimitiveArrayCritical(vals, 0);
+    int res = mat_get<double>(me, row, col, count, values);
+    env->ReleasePrimitiveArrayCritical(vals, values, 0);
+    return res;
+}
+
+JNIEXPORT jdoubleArray JNICALL Java_org_opencv_core_Mat_nGet
+    (JNIEnv* env, jclass cls, jlong self, jint row, jint col, jint count)
+{
+    cv::Mat* me = (cv::Mat*) self;
+    if(! self) return 0; // no native object behind
+    if(me->rows<=row || me->cols<=col) return 0; // indexes out of range
+
+    jdoubleArray res = env->NewDoubleArray(me->channels());
+    if(res){
+        jdouble buff[me->channels()];
+        int i;
+        switch(me->depth()){
+            case CV_8U:  for(i=0; i<me->channels(); i++) buff[i] = *((unsigned char*) me->ptr(row, col) + i); break;
+            case CV_8S:  for(i=0; i<me->channels(); i++) buff[i] = *((signed char*)   me->ptr(row, col) + i); break;
+            case CV_16U: for(i=0; i<me->channels(); i++) buff[i] = *((unsigned short*)me->ptr(row, col) + i); break;
+            case CV_16S: for(i=0; i<me->channels(); i++) buff[i] = *((signed short*)  me->ptr(row, col) + i); break;
+            case CV_32S: for(i=0; i<me->channels(); i++) buff[i] = *((int*)           me->ptr(row, col) + i); break;
+            case CV_32F: for(i=0; i<me->channels(); i++) buff[i] = *((float*)         me->ptr(row, col) + i); break;
+            case CV_64F: for(i=0; i<me->channels(); i++) buff[i] = *((double*)        me->ptr(row, col) + i); break;
+        }
+        env->SetDoubleArrayRegion(res, 0, me->channels(), buff);
+    }
+    return res;
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_core_Mat_nDump
+  (JNIEnv *env, jclass cls, jlong self)
+{
+    cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL
+    std::stringstream s;
+    s << *me;
+    return env->NewStringUTF(s.str().c_str());
+}
+
+
+} // extern "C"
diff --git a/modules/java/src/cpp/VideoCapture.cpp b/modules/java/src/cpp/VideoCapture.cpp
new file mode 100644
index 0000000000..9659ab3127
--- /dev/null
+++ b/modules/java/src/cpp/VideoCapture.cpp
@@ -0,0 +1,454 @@
+//
+// This file is auto-generated, please don't edit!
+//
+
+#include <jni.h>
+
+#ifdef DEBUG
+#include <android/log.h>
+#define MODULE_LOG_TAG "OpenCV.highgui"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
+#endif // DEBUG
+
+#include "opencv2/highgui/highgui_c.h"
+#include "opencv2/highgui/highgui.hpp"
+using namespace cv;
+
+
+extern "C" {
+
+//
+//   VideoCapture::VideoCapture()
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__
+  (JNIEnv* env, jclass cls)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__()");
+#endif // DEBUG
+        
+        VideoCapture* _retval_ = new VideoCapture(  );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__()}");
+        return 0;
+    }
+}
+
+
+//
+//   VideoCapture::VideoCapture(int device)
+//
+
+
+JNIEXPORT jlong JNICALL Java_org_opencv_highgui_VideoCapture_n_1VideoCapture__I
+  (JNIEnv* env, jclass cls, jint device)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I()");
+#endif // DEBUG
+        
+        VideoCapture* _retval_ = new VideoCapture( device );
+        
+        return (jlong) _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1VideoCapture__I() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1VideoCapture__I()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  double VideoCapture::get(int propId)
+//
+
+
+JNIEXPORT jdouble JNICALL Java_org_opencv_highgui_VideoCapture_n_1get
+  (JNIEnv* env, jclass cls, jlong self, jint propId)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1get()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        double _retval_ = me->get( propId );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1get() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1get() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1get()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::grab()
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1grab()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->grab(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1grab() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1grab() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1grab()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::isOpened()
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1isOpened
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1isOpened()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->isOpened(  );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1isOpened() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1isOpened() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1isOpened()}");
+        return 0;
+    }
+}
+
+
+//
+//  bool VideoCapture::open(int device)
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1open__JI
+  (JNIEnv* env, jclass cls, jlong self, jint device)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1open__JI()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->open( device );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1open__JI() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1open__JI() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1open__JI()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::read(Mat image)
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1read
+  (JNIEnv* env, jclass cls, jlong self, jlong image_nativeObj)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1read()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->read( image );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1read() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1read() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1read()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  void VideoCapture::release()
+//
+
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1release
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1release()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        me->release(  );
+        
+        return;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1release() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1release() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1release()}");
+        return;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::retrieve(Mat image, int channel = 0)
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJI
+  (JNIEnv* env, jclass cls, jlong self, jlong image_nativeObj, jint channel)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->retrieve( image, channel );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJI() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJI()}");
+        return 0;
+    }
+}
+
+
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1retrieve__JJ
+  (JNIEnv* env, jclass cls, jlong self, jlong image_nativeObj)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        Mat& image = *((Mat*)image_nativeObj);
+        bool _retval_ = me->retrieve( image );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1retrieve__JJ() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1retrieve__JJ()}");
+        return 0;
+    }
+}
+
+
+
+//
+//  bool VideoCapture::set(int propId, double value)
+//
+
+
+JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1set
+  (JNIEnv* env, jclass cls, jlong self, jint propId, jdouble value)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1set()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+        bool _retval_ = me->set( propId, value );
+        
+        return _retval_;
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1set() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return 0;
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1set() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1set()}");
+        return 0;
+    }
+}
+
+JNIEXPORT jstring JNICALL Java_org_opencv_highgui_VideoCapture_n_1getSupportedPreviewSizes
+  (JNIEnv *env, jclass cls, jlong self)
+{
+    try {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1set()");
+#endif // DEBUG
+        VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
+		union {double prop; const char* name;} u;
+        u.prop = me->get(CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING);
+        return env->NewStringUTF(u.name);
+    } catch(cv::Exception e) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched cv::Exception: %s", e.what());
+#endif // DEBUG
+        jclass je = env->FindClass("org/opencv/core/CvException");
+        if(!je) je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, e.what());
+        return env->NewStringUTF("");
+    } catch (...) {
+#ifdef DEBUG
+        LOGD("highgui::VideoCapture_n_1getSupportedPreviewSizes() catched unknown exception (...)");
+#endif // DEBUG
+        jclass je = env->FindClass("java/lang/Exception");
+        env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1getSupportedPreviewSizes()}");
+        return env->NewStringUTF("");
+    }
+}
+
+
+
+//
+//  native support for java finalize()
+//  static void VideoCapture::n_delete( __int64 self )
+//
+
+JNIEXPORT void JNICALL Java_org_opencv_highgui_VideoCapture_n_1delete
+  (JNIEnv* env, jclass cls, jlong self)
+{
+    delete (VideoCapture*) self;
+}
+
+} // extern "C"
+
diff --git a/modules/java/src/cpp/converters.cpp b/modules/java/src/cpp/converters.cpp
new file mode 100644
index 0000000000..40cdd3bbc1
--- /dev/null
+++ b/modules/java/src/cpp/converters.cpp
@@ -0,0 +1,380 @@
+#include "converters.h"
+
+#ifdef DEBUG
+#include <android/log.h>
+#define MODULE_LOG_TAG "OpenCV.converters"
+#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__))
+#else //DEBUG
+#define LOGD(...)
+#endif //DEBUG
+
+using namespace cv;
+
+#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
+
+
+// vector_int
+
+void Mat_to_vector_int(Mat& mat, vector<int>& v_int)
+{
+    v_int.clear();
+    CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1);
+    v_int = (vector<int>) mat;
+}
+
+void vector_int_to_Mat(vector<int>& v_int, Mat& mat)
+{
+    mat = Mat(v_int, true);
+}
+
+
+//vector_double
+
+void Mat_to_vector_double(Mat& mat, vector<double>& v_double)
+{
+    v_double.clear();
+    CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1);
+    v_double = (vector<double>) mat;
+}
+
+void vector_double_to_Mat(vector<double>& v_double, Mat& mat)
+{
+    mat = Mat(v_double, true);
+}
+
+
+// vector_float
+
+void Mat_to_vector_float(Mat& mat, vector<float>& v_float)
+{
+    v_float.clear();
+    CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1);
+    v_float = (vector<float>) mat;
+}
+
+void vector_float_to_Mat(vector<float>& v_float, Mat& mat)
+{
+    mat = Mat(v_float, true);
+}
+
+
+//vector_uchar
+
+void Mat_to_vector_uchar(Mat& mat, vector<uchar>& v_uchar)
+{
+    v_uchar.clear();
+    CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1);
+    v_uchar = (vector<uchar>) mat;
+}
+
+void vector_uchar_to_Mat(vector<uchar>& v_uchar, Mat& mat)
+{
+    mat = Mat(v_uchar, true);
+}
+
+void Mat_to_vector_char(Mat& mat, vector<char>& v_char)
+{
+    v_char.clear();
+    CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1);
+    v_char = (vector<char>) mat;
+}
+
+void vector_char_to_Mat(vector<char>& v_char, Mat& mat)
+{
+    mat = Mat(v_char, true);
+}
+
+
+//vector_Rect
+
+void Mat_to_vector_Rect(Mat& mat, vector<Rect>& v_rect)
+{
+    v_rect.clear();
+    CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1);
+    v_rect = (vector<Rect>) mat;
+}
+
+void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat)
+{
+    mat = Mat(v_rect, true);
+}
+
+
+//vector_Point
+void Mat_to_vector_Point(Mat& mat, vector<Point>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1);
+    v_point = (vector<Point>) mat;
+}
+
+//vector_Point2f
+void Mat_to_vector_Point2f(Mat& mat, vector<Point2f>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1);
+    v_point = (vector<Point2f>) mat;
+}
+
+//vector_Point2d
+void Mat_to_vector_Point2d(Mat& mat, vector<Point2d>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1);
+    v_point = (vector<Point2d>) mat;
+}
+
+
+//vector_Point3i
+void Mat_to_vector_Point3i(Mat& mat, vector<Point3i>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1);
+    v_point = (vector<Point3i>) mat;
+}
+
+//vector_Point3f
+void Mat_to_vector_Point3f(Mat& mat, vector<Point3f>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1);
+    v_point = (vector<Point3f>) mat;
+}
+
+//vector_Point3d
+void Mat_to_vector_Point3d(Mat& mat, vector<Point3d>& v_point)
+{
+    v_point.clear();
+    CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1);
+    v_point = (vector<Point3d>) mat;
+}
+
+
+void vector_Point_to_Mat(vector<Point>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+void vector_Point2f_to_Mat(vector<Point2f>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+void vector_Point2d_to_Mat(vector<Point2d>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+void vector_Point3i_to_Mat(vector<Point3i>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+void vector_Point3f_to_Mat(vector<Point3f>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+void vector_Point3d_to_Mat(vector<Point3d>& v_point, Mat& mat)
+{
+    mat = Mat(v_point, true);
+}
+
+
+//vector_KeyPoint
+void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp)
+{
+    v_kp.clear();
+    CHECK_MAT(mat.type()==CV_64FC(7) && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<double, 7> v = mat.at< Vec<double, 7> >(i, 0);
+        KeyPoint kp((float)v[0], (float)v[1], (float)v[2], (float)v[3], (float)v[4], (int)v[5], (int)v[6]);
+        v_kp.push_back(kp);
+    }
+    return;
+}
+
+
+void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat)
+{
+    int count = v_kp.size();
+    mat.create(count, 1, CV_64FC(7));
+    for(int i=0; i<count; i++)
+    {
+        KeyPoint kp = v_kp[i];
+        mat.at< Vec<double, 7> >(i, 0) = Vec<double, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id);
+    }
+}
+
+
+//vector_Mat
+void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat)
+{
+    v_mat.clear();
+    if(mat.type() == CV_32SC2 && mat.cols == 1)
+    {
+        v_mat.reserve(mat.rows);
+        for(int i=0; i<mat.rows; i++)
+        {
+            Vec<int, 2> a = mat.at< Vec<int, 2> >(i, 0);
+            long long addr = (((long long)a[0])<<32) | a[1];
+            Mat& m = *( (Mat*) addr );
+            v_mat.push_back(m);
+        }
+    } else {
+        LOGD("Mat_to_vector_Mat() FAILED: mat.type() == CV_32SC2 && mat.cols == 1");
+    }
+}
+
+
+void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat)
+{
+    int count = v_mat.size();
+    mat.create(count, 1, CV_32SC2);
+    for(int i=0; i<count; i++)
+    {
+        long long addr = (long long) new Mat(v_mat[i]);
+        mat.at< Vec<int, 2> >(i, 0) = Vec<int, 2>(addr>>32, addr&0xffffffff);
+    }
+}
+
+//vector_DMatch
+void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm)
+{
+    v_dm.clear();
+    CHECK_MAT(mat.type()==CV_64FC4 && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<double, 4> v = mat.at< Vec<double, 4> >(i, 0);
+        DMatch dm((int)v[0], (int)v[1], (int)v[2], (float)v[3]);
+        v_dm.push_back(dm);
+    }
+    return;
+}
+
+
+void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat)
+{
+    int count = v_dm.size();
+    mat.create(count, 1, CV_64FC4);
+    for(int i=0; i<count; i++)
+    {
+        DMatch dm = v_dm[i];
+        mat.at< Vec<double, 4> >(i, 0) = Vec<double, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance);
+    }
+}
+
+void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt)
+{
+    vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        vector<Point> vpt;
+        Mat_to_vector_Point(vm[i], vpt);
+        vv_pt.push_back(vpt);
+    }
+}
+
+void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp)
+{
+    vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        vector<KeyPoint> vkp;
+        Mat_to_vector_KeyPoint(vm[i], vkp);
+        vv_kp.push_back(vkp);
+    }
+}
+
+void vector_vector_KeyPoint_to_Mat(vector< vector< KeyPoint > >& vv_kp, Mat& mat)
+{
+    vector<Mat> vm;
+    vm.reserve( vv_kp.size() );
+    for(size_t i=0; i<vv_kp.size(); i++)
+    {
+        Mat m;
+        vector_KeyPoint_to_Mat(vv_kp[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void Mat_to_vector_vector_DMatch(Mat& mat, vector< vector< DMatch > >& vv_dm)
+{
+    vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        vector<DMatch> vdm;
+        Mat_to_vector_DMatch(vm[i], vdm);
+        vv_dm.push_back(vdm);
+    }
+}
+
+void vector_vector_DMatch_to_Mat(vector< vector< DMatch > >& vv_dm, Mat& mat)
+{
+    vector<Mat> vm;
+    vm.reserve( vv_dm.size() );
+    for(size_t i=0; i<vv_dm.size(); i++)
+    {
+        Mat m;
+        vector_DMatch_to_Mat(vv_dm[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void Mat_to_vector_vector_char(Mat& mat, vector< vector< char > >& vv_ch)
+{
+    vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        vector<char> vch;
+        Mat_to_vector_char(vm[i], vch);
+        vv_ch.push_back(vch);
+    }
+}
+
+void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat)
+{
+    vector<Mat> vm;
+    vm.reserve( vv_ch.size() );
+    for(size_t i=0; i<vv_ch.size(); i++)
+    {
+        Mat m;
+        vector_char_to_Mat(vv_ch[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat)
+{
+    vector<Mat> vm;
+    vm.reserve( vv_pt.size() );
+    for(size_t i=0; i<vv_pt.size(); i++)
+    {
+        Mat m;
+        vector_Point2f_to_Mat(vv_pt[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void vector_Vec4f_to_Mat(vector<Vec4f>& v_vec, Mat& mat)
+{
+    mat = Mat(v_vec, true);
+}
+
+void vector_Vec6f_to_Mat(vector<Vec6f>& v_vec, Mat& mat)
+{
+    mat = Mat(v_vec, true);
+}
diff --git a/modules/java/src/cpp/converters.h b/modules/java/src/cpp/converters.h
new file mode 100644
index 0000000000..71c016a29a
--- /dev/null
+++ b/modules/java/src/cpp/converters.h
@@ -0,0 +1,64 @@
+#include <jni.h>
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "features2d_manual.hpp"
+
+
+void Mat_to_vector_int(cv::Mat& mat, std::vector<int>& v_int);
+void vector_int_to_Mat(std::vector<int>& v_int, cv::Mat& mat);
+
+void Mat_to_vector_double(cv::Mat& mat, std::vector<double>& v_double);
+void vector_double_to_Mat(std::vector<double>& v_double, cv::Mat& mat);
+
+void Mat_to_vector_float(cv::Mat& mat, std::vector<float>& v_float);
+void vector_float_to_Mat(std::vector<float>& v_float, cv::Mat& mat);
+
+void Mat_to_vector_uchar(cv::Mat& mat, std::vector<uchar>& v_uchar);
+void vector_uchar_to_Mat(std::vector<uchar>& v_uchar, cv::Mat& mat);
+
+void Mat_to_vector_char(cv::Mat& mat, std::vector<char>& v_char);
+void vector_char_to_Mat(std::vector<char>& v_char, cv::Mat& mat);
+
+void Mat_to_vector_Rect(cv::Mat& mat, std::vector<cv::Rect>& v_rect);
+void vector_Rect_to_Mat(std::vector<cv::Rect>& v_rect, cv::Mat& mat);
+
+
+void Mat_to_vector_Point(cv::Mat& mat, std::vector<cv::Point>& v_point);
+void Mat_to_vector_Point2f(cv::Mat& mat, std::vector<cv::Point2f>& v_point);
+void Mat_to_vector_Point2d(cv::Mat& mat, std::vector<cv::Point2d>& v_point);
+void Mat_to_vector_Point3i(cv::Mat& mat, std::vector<cv::Point3i>& v_point);
+void Mat_to_vector_Point3f(cv::Mat& mat, std::vector<cv::Point3f>& v_point);
+void Mat_to_vector_Point3d(cv::Mat& mat, std::vector<cv::Point3d>& v_point);
+
+void vector_Point_to_Mat(std::vector<cv::Point>& v_point, cv::Mat& mat);
+void vector_Point2f_to_Mat(std::vector<cv::Point2f>& v_point, cv::Mat& mat);
+void vector_Point2d_to_Mat(std::vector<cv::Point2d>& v_point, cv::Mat& mat);
+void vector_Point3i_to_Mat(std::vector<cv::Point3i>& v_point, cv::Mat& mat);
+void vector_Point3f_to_Mat(std::vector<cv::Point3f>& v_point, cv::Mat& mat);
+void vector_Point3d_to_Mat(std::vector<cv::Point3d>& v_point, cv::Mat& mat);
+
+void vector_Vec4f_to_Mat(std::vector<cv::Vec4f>& v_vec, cv::Mat& mat);
+void vector_Vec6f_to_Mat(std::vector<cv::Vec6f>& v_vec, cv::Mat& mat);
+
+void Mat_to_vector_KeyPoint(cv::Mat& mat, std::vector<cv::KeyPoint>& v_kp);
+void vector_KeyPoint_to_Mat(std::vector<cv::KeyPoint>& v_kp, cv::Mat& mat);
+
+void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat);
+void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat);
+
+void Mat_to_vector_DMatch(cv::Mat& mat, std::vector<cv::DMatch>& v_dm);
+void vector_DMatch_to_Mat(std::vector<cv::DMatch>& v_dm, cv::Mat& mat);
+
+void Mat_to_vector_vector_KeyPoint(cv::Mat& mat, std::vector< std::vector< cv::KeyPoint > >& vv_kp);
+void vector_vector_KeyPoint_to_Mat(std::vector< std::vector< cv::KeyPoint > >& vv_kp, cv::Mat& mat);
+
+void Mat_to_vector_vector_DMatch(cv::Mat& mat, std::vector< std::vector< cv::DMatch > >& vv_dm);
+void vector_vector_DMatch_to_Mat(std::vector< std::vector< cv::DMatch > >& vv_dm, cv::Mat& mat);
+
+void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >& vv_ch);
+void vector_vector_char_to_Mat(std::vector< std::vector< char > >& vv_ch, cv::Mat& mat);
+
+void Mat_to_vector_vector_Point(cv::Mat& mat, std::vector< std::vector< cv::Point > >& vv_pt);
+void vector_vector_Point2f_to_Mat(std::vector< std::vector< cv::Point2f > >& vv_pt, cv::Mat& mat);
+
diff --git a/modules/java/src/cpp/features2d_manual.hpp b/modules/java/src/cpp/features2d_manual.hpp
new file mode 100644
index 0000000000..e0fc609f2d
--- /dev/null
+++ b/modules/java/src/cpp/features2d_manual.hpp
@@ -0,0 +1,444 @@
+#ifndef __OPENCV_FEATURES_2D_MANUAL_HPP__
+#define __OPENCV_FEATURES_2D_MANUAL_HPP__
+
+#include "opencv2/features2d/features2d.hpp"
+
+namespace cv
+{
+
+class CV_EXPORTS_AS(FeatureDetector) javaFeatureDetector : public FeatureDetector
+{
+public:
+#if 0
+    CV_WRAP void detect( const Mat& image, CV_OUT vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
+    CV_WRAP void detect( const vector<Mat>& images, CV_OUT vector<vector<KeyPoint> >& keypoints, const vector<Mat>& masks=vector<Mat>() ) const;
+    CV_WRAP virtual bool empty() const;
+#endif
+
+    enum
+    {
+        FAST          = 1,
+        STAR          = 2,
+        SIFT          = 3,
+        SURF          = 4,
+        ORB           = 5,
+        MSER          = 6,
+        GFTT          = 7,
+        HARRIS        = 8,
+        SIMPLEBLOB    = 9,
+        DENSE         = 10,
+
+
+        GRIDRETECTOR = 1000,
+
+        GRID_FAST          = GRIDRETECTOR + FAST,
+        GRID_STAR          = GRIDRETECTOR + STAR,
+        GRID_SIFT          = GRIDRETECTOR + SIFT,
+        GRID_SURF          = GRIDRETECTOR + SURF,
+        GRID_ORB           = GRIDRETECTOR + ORB,
+        GRID_MSER          = GRIDRETECTOR + MSER,
+        GRID_GFTT          = GRIDRETECTOR + GFTT,
+        GRID_HARRIS        = GRIDRETECTOR + HARRIS,
+        GRID_SIMPLEBLOB    = GRIDRETECTOR + SIMPLEBLOB,
+        GRID_DENSE         = GRIDRETECTOR + DENSE,
+
+
+        PYRAMIDDETECTOR = 2000,
+
+        PYRAMID_FAST       = PYRAMIDDETECTOR + FAST,
+        PYRAMID_STAR       = PYRAMIDDETECTOR + STAR,
+        PYRAMID_SIFT       = PYRAMIDDETECTOR + SIFT,
+        PYRAMID_SURF       = PYRAMIDDETECTOR + SURF,
+        PYRAMID_ORB        = PYRAMIDDETECTOR + ORB,
+        PYRAMID_MSER       = PYRAMIDDETECTOR + MSER,
+        PYRAMID_GFTT       = PYRAMIDDETECTOR + GFTT,
+        PYRAMID_HARRIS     = PYRAMIDDETECTOR + HARRIS,
+        PYRAMID_SIMPLEBLOB = PYRAMIDDETECTOR + SIMPLEBLOB,
+        PYRAMID_DENSE      = PYRAMIDDETECTOR + DENSE,
+
+        DYNAMICDETECTOR = 3000,
+
+        DYNAMIC_FAST       = DYNAMICDETECTOR + FAST,
+        DYNAMIC_STAR       = DYNAMICDETECTOR + STAR,
+        DYNAMIC_SIFT       = DYNAMICDETECTOR + SIFT,
+        DYNAMIC_SURF       = DYNAMICDETECTOR + SURF,
+        DYNAMIC_ORB        = DYNAMICDETECTOR + ORB,
+        DYNAMIC_MSER       = DYNAMICDETECTOR + MSER,
+        DYNAMIC_GFTT       = DYNAMICDETECTOR + GFTT,
+        DYNAMIC_HARRIS     = DYNAMICDETECTOR + HARRIS,
+        DYNAMIC_SIMPLEBLOB = DYNAMICDETECTOR + SIMPLEBLOB,
+        DYNAMIC_DENSE      = DYNAMICDETECTOR + DENSE
+    };
+
+    //supported: FAST STAR SIFT SURF ORB MSER GFTT HARRIS Grid(XXXX) Pyramid(XXXX) Dynamic(XXXX)
+    //not supported: SimpleBlob, Dense
+    CV_WRAP static javaFeatureDetector* create( int detectorType )
+    {
+        string name;
+        if (detectorType > DYNAMICDETECTOR)
+        {
+            name = "Dynamic";
+            detectorType -= DYNAMICDETECTOR;
+        }
+        if (detectorType > PYRAMIDDETECTOR)
+        {
+            name = "Pyramid";
+            detectorType -= PYRAMIDDETECTOR;
+        }
+        if (detectorType > GRIDRETECTOR)
+        {
+            name = "Grid";
+            detectorType -= GRIDRETECTOR;
+        }
+
+        switch(detectorType)
+        {
+        case FAST:
+            name += "FAST";
+            break;
+        case STAR:
+            name += "STAR";
+            break;
+        case SIFT:
+            name += "SIFT";
+            break;
+        case SURF:
+            name += "SURF";
+            break;
+        case ORB:
+            name += "ORB";
+            break;
+        case MSER:
+            name += "MSER";
+            break;
+        case GFTT:
+            name += "GFTT";
+            break;
+        case HARRIS:
+            name += "HARRIS";
+            break;
+        case SIMPLEBLOB:
+            name += "SimpleBlob";
+            break;
+        case DENSE:
+            name += "Dense";
+            break;
+        default:
+            CV_Error( CV_StsBadArg, "Specified feature detector type is not supported." );
+            break;
+        }
+
+        Ptr<FeatureDetector> detector = FeatureDetector::create(name);
+        detector.addref();
+        return (javaFeatureDetector*)((FeatureDetector*) detector);
+    }
+
+    CV_WRAP void write( const string& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        ((FeatureDetector*)this)->write(fs);
+        fs.release();
+    }
+
+    CV_WRAP void read( const string& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        ((FeatureDetector*)this)->read(fs.root());
+        fs.release();
+    }
+};
+
+class CV_EXPORTS_AS(DescriptorMatcher) javaDescriptorMatcher : public DescriptorMatcher
+{
+public:
+#if 0
+    CV_WRAP virtual bool isMaskSupported() const;
+    CV_WRAP virtual void add( const vector<Mat>& descriptors );
+    CV_WRAP const vector<Mat>& getTrainDescriptors() const;
+    CV_WRAP virtual void clear();
+    CV_WRAP virtual bool empty() const;
+    CV_WRAP virtual void train();
+    CV_WRAP void match( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                CV_OUT vector<DMatch>& matches, const Mat& mask=Mat() ) const;
+    CV_WRAP void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                   CV_OUT vector<vector<DMatch> >& matches, int k,
+                   const Mat& mask=Mat(), bool compactResult=false ) const;
+    CV_WRAP void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                      CV_OUT vector<vector<DMatch> >& matches, float maxDistance,
+                      const Mat& mask=Mat(), bool compactResult=false ) const;
+    CV_WRAP void match( const Mat& queryDescriptors, CV_OUT vector<DMatch>& matches,
+                const vector<Mat>& masks=vector<Mat>() );
+    CV_WRAP void knnMatch( const Mat& queryDescriptors, CV_OUT vector<vector<DMatch> >& matches, int k,
+           const vector<Mat>& masks=vector<Mat>(), bool compactResult=false );
+    CV_WRAP void radiusMatch( const Mat& queryDescriptors, CV_OUT vector<vector<DMatch> >& matches, float maxDistance,
+                   const vector<Mat>& masks=vector<Mat>(), bool compactResult=false );
+#endif
+
+    enum
+    {
+        FLANNBASED            = 1,
+        BRUTEFORCE            = 2,
+        BRUTEFORCE_L1         = 3,
+        BRUTEFORCE_HAMMING    = 4,
+        BRUTEFORCE_HAMMINGLUT = 5,
+        BRUTEFORCE_SL2        = 6
+    };
+
+    CV_WRAP_AS(clone) javaDescriptorMatcher* jclone( bool emptyTrainData=false ) const
+    {
+        Ptr<DescriptorMatcher> matcher = this->clone(emptyTrainData);
+        matcher.addref();
+        return (javaDescriptorMatcher*)((DescriptorMatcher*) matcher);
+    }
+    
+    //supported: FlannBased, BruteForce, BruteForce-L1, BruteForce-Hamming, BruteForce-HammingLUT
+    CV_WRAP static javaDescriptorMatcher* create( int matcherType )
+    {
+        string name;
+
+        switch(matcherType)
+        {
+        case FLANNBASED:
+            name = "FlannBased";
+            break;
+        case BRUTEFORCE:
+            name = "BruteForce";
+            break;
+        case BRUTEFORCE_L1:
+            name = "BruteForce-L1";
+            break;
+        case BRUTEFORCE_HAMMING:
+            name = "BruteForce-Hamming";
+            break;
+        case BRUTEFORCE_HAMMINGLUT:
+            name = "BruteForce-HammingLUT";
+            break;
+        case BRUTEFORCE_SL2:
+            name = "BruteForce-SL2";
+            break;
+        default:
+            CV_Error( CV_StsBadArg, "Specified descriptor matcher type is not supported." );
+            break;
+        }
+
+        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create(name);
+        matcher.addref();
+        return (javaDescriptorMatcher*)((DescriptorMatcher*) matcher);
+    }
+
+    CV_WRAP void write( const string& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        ((DescriptorMatcher*)this)->write(fs);
+        fs.release();
+    }
+
+    CV_WRAP void read( const string& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        ((DescriptorMatcher*)this)->read(fs.root());
+        fs.release();
+    }
+};
+
+class CV_EXPORTS_AS(DescriptorExtractor) javaDescriptorExtractor : public DescriptorExtractor
+{
+public:
+#if 0
+    CV_WRAP void compute( const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors ) const;
+    CV_WRAP void compute( const vector<Mat>& images, vector<vector<KeyPoint> >& keypoints, CV_OUT vector<Mat>& descriptors ) const;
+    CV_WRAP virtual int descriptorSize() const;
+    CV_WRAP virtual int descriptorType() const;
+
+    CV_WRAP virtual bool empty() const;
+#endif
+
+    enum
+    {
+        SIFT  = 1,
+        SURF  = 2,
+        ORB   = 3,
+        BRIEF = 4,
+
+
+        OPPONENTEXTRACTOR = 1000,
+
+
+
+        OPPONENT_SIFT  = OPPONENTEXTRACTOR + SIFT,
+        OPPONENT_SURF  = OPPONENTEXTRACTOR + SURF,
+        OPPONENT_ORB   = OPPONENTEXTRACTOR + ORB,
+        OPPONENT_BRIEF = OPPONENTEXTRACTOR + BRIEF
+    };
+
+    //supported SIFT, SURF, ORB, BRIEF, Opponent(XXXX)
+    //not supported: Calonder
+    CV_WRAP static javaDescriptorExtractor* create( int extractorType )
+    {
+        string name;
+
+        if (extractorType > OPPONENTEXTRACTOR)
+        {
+            name = "Opponent";
+            extractorType -= OPPONENTEXTRACTOR;
+        }
+
+        switch(extractorType)
+        {
+        case SIFT:
+            name += "SIFT";
+            break;
+        case SURF:
+            name += "SURF";
+            break;
+        case ORB:
+            name += "ORB";
+            break;
+        case BRIEF:
+            name += "BRIEF";
+            break;
+        default:
+            CV_Error( CV_StsBadArg, "Specified descriptor extractor type is not supported." );
+            break;
+        }
+
+        Ptr<DescriptorExtractor> extractor = DescriptorExtractor::create(name);
+        extractor.addref();
+        return (javaDescriptorExtractor*)((DescriptorExtractor*) extractor);
+    }
+
+    CV_WRAP void write( const string& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        ((DescriptorExtractor*)this)->write(fs);
+        fs.release();
+    }
+
+    CV_WRAP void read( const string& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        ((DescriptorExtractor*)this)->read(fs.root());
+        fs.release();
+    }
+};
+
+class CV_EXPORTS_AS(GenericDescriptorMatcher) javaGenericDescriptorMatcher : public GenericDescriptorMatcher
+{
+public:
+#if 0
+    CV_WRAP virtual void add( const vector<Mat>& images,
+                      vector<vector<KeyPoint> >& keypoints );
+    CV_WRAP const vector<Mat>& getTrainImages() const;
+    CV_WRAP const vector<vector<KeyPoint> >& getTrainKeypoints() const;
+    CV_WRAP virtual void clear();
+    CV_WRAP virtual bool isMaskSupported();
+    CV_WRAP virtual void train();
+    CV_WRAP void classify( const Mat& queryImage, CV_IN_OUT vector<KeyPoint>& queryKeypoints,
+                           const Mat& trainImage, vector<KeyPoint>& trainKeypoints ) const;
+    CV_WRAP void classify( const Mat& queryImage, CV_IN_OUT vector<KeyPoint>& queryKeypoints );
+    CV_WRAP void match( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                const Mat& trainImage, vector<KeyPoint>& trainKeypoints,
+                CV_OUT vector<DMatch>& matches, const Mat& mask=Mat() ) const;
+    CV_WRAP void knnMatch( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                   const Mat& trainImage, vector<KeyPoint>& trainKeypoints,
+                   CV_OUT vector<vector<DMatch> >& matches, int k,
+                   const Mat& mask=Mat(), bool compactResult=false ) const;
+    CV_WRAP void radiusMatch( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                      const Mat& trainImage, vector<KeyPoint>& trainKeypoints,
+                      CV_OUT vector<vector<DMatch> >& matches, float maxDistance,
+                      const Mat& mask=Mat(), bool compactResult=false ) const;
+    CV_WRAP void match( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                CV_OUT vector<DMatch>& matches, const vector<Mat>& masks=vector<Mat>() );
+    CV_WRAP void knnMatch( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                   CV_OUT vector<vector<DMatch> >& matches, int k,
+                   const vector<Mat>& masks=vector<Mat>(), bool compactResult=false );
+    CV_WRAP void radiusMatch( const Mat& queryImage, vector<KeyPoint>& queryKeypoints,
+                      CV_OUT vector<vector<DMatch> >& matches, float maxDistance,
+                      const vector<Mat>& masks=vector<Mat>(), bool compactResult=false );
+    CV_WRAP virtual bool empty() const;
+#endif
+
+    enum
+    {
+        ONEWAY = 1,
+        FERN   = 2
+    };
+
+    CV_WRAP_AS(clone) javaGenericDescriptorMatcher* jclone( bool emptyTrainData=false ) const
+    {
+        Ptr<GenericDescriptorMatcher> matcher = this->clone(emptyTrainData);
+        matcher.addref();
+        return (javaGenericDescriptorMatcher*)((GenericDescriptorMatcher*) matcher);
+    }
+    
+    //supported: OneWay, Fern
+    //unsupported: Vector
+    CV_WRAP static javaGenericDescriptorMatcher* create( int matcherType )
+    {
+        string name;
+
+        switch(matcherType)
+        {
+        case ONEWAY:
+            name = "ONEWAY";
+            break;
+        case FERN:
+            name = "FERN";
+            break;
+        default:
+            CV_Error( CV_StsBadArg, "Specified generic descriptor matcher type is not supported." );
+            break;
+        }
+
+        Ptr<GenericDescriptorMatcher> matcher = GenericDescriptorMatcher::create(name);
+        matcher.addref();
+        return (javaGenericDescriptorMatcher*)((GenericDescriptorMatcher*) matcher);
+    }
+
+    CV_WRAP void write( const string& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        ((GenericDescriptorMatcher*)this)->write(fs);
+        fs.release();
+    }
+
+    CV_WRAP void read( const string& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        ((GenericDescriptorMatcher*)this)->read(fs.root());
+        fs.release();
+    }
+};
+
+#if 0
+enum
+{ 
+          DRAW_OVER_OUTIMG = 1, // Output image matrix will not be created (Mat::create).
+                                // Matches will be drawn on existing content of output image.
+          NOT_DRAW_SINGLE_POINTS = 2, // Single keypoints will not be drawn.
+          DRAW_RICH_KEYPOINTS = 4 // For each keypoint the circle around keypoint with keypoint size and
+                                  // orientation will be drawn.
+};
+
+// Draw keypoints.
+CV_EXPORTS_W void drawKeypoints( const Mat& image, const vector<KeyPoint>& keypoints, Mat& outImage,
+                               const Scalar& color=Scalar::all(-1), int flags=0 );
+
+// Draws matches of keypints from two images on output image.
+CV_EXPORTS_W void drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,
+                             const Mat& img2, const vector<KeyPoint>& keypoints2,
+                             const vector<DMatch>& matches1to2, Mat& outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const vector<char>& matchesMask=vector<char>(), int flags=0 );
+
+CV_EXPORTS_AS(drawMatches2) void drawMatches( const Mat& img1, const vector<KeyPoint>& keypoints1,
+                             const Mat& img2, const vector<KeyPoint>& keypoints2,
+                             const vector<vector<DMatch> >& matches1to2, Mat& outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const vector<vector<char> >& matchesMask=vector<vector<char> >(), int flags=0);
+                             
+#endif
+
+} //cv
+
+#endif // __OPENCV_FEATURES_2D_MANUAL_HPP__
diff --git a/modules/java/src/cpp/jni_part.cpp b/modules/java/src/cpp/jni_part.cpp
new file mode 100644
index 0000000000..8273d94314
--- /dev/null
+++ b/modules/java/src/cpp/jni_part.cpp
@@ -0,0 +1,24 @@
+#include <jni.h>
+
+extern "C" {
+
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM* vm, void* reserved)
+{
+    JNIEnv* env;
+    if (vm->GetEnv((void**) &env, JNI_VERSION_1_6) != JNI_OK)
+        return -1;
+
+    /* get class with (*env)->FindClass */
+    /* register methods with (*env)->RegisterNatives */
+
+    return JNI_VERSION_1_6;
+}
+
+JNIEXPORT void JNICALL
+JNI_OnUnload(JavaVM *vm, void *reserved)
+{
+  //do nothing
+}
+
+} // extern "C"
\ No newline at end of file
diff --git a/modules/java/src/cpp/utils.cpp b/modules/java/src/cpp/utils.cpp
new file mode 100644
index 0000000000..d06ef74919
--- /dev/null
+++ b/modules/java/src/cpp/utils.cpp
@@ -0,0 +1,76 @@
+#include <jni.h>
+
+#include "opencv2/core/core.hpp"
+
+#include <android/bitmap.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Class:     org_opencv_android_Utils
+ * Method:    nBitmapToMat(Bitmap b)
+ * Signature: (L)J
+ */
+
+JNIEXPORT jlong JNICALL Java_org_opencv_android_Utils_nBitmapToMat
+  (JNIEnv * env, jclass cls, jobject bitmap)
+{
+    AndroidBitmapInfo  info;
+    void*              pixels;
+    cv::Mat*           m = new cv::Mat();
+
+	if ( AndroidBitmap_getInfo(env, bitmap, &info) < 0 )
+        return (jlong)m; // can't get info
+
+    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
+        return (jlong)m; // incompatible format
+
+    if ( AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0 )
+        return (jlong)m; // can't get pixels
+
+    m->create(info.height, info.width, CV_8UC4);
+    if(m->data && pixels)
+        memcpy(m->data, pixels, info.height * info.width * 4);
+
+    AndroidBitmap_unlockPixels(env, bitmap);
+
+    return (jlong)m;
+}
+
+/*
+ * Class:     org_opencv_android_Utils
+ * Method:    nBitmapToMat(long m, Bitmap b)
+ * Signature: (JL)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_opencv_android_Utils_nMatToBitmap
+  (JNIEnv * env, jclass cls, jlong m, jobject bitmap)
+{
+    AndroidBitmapInfo  info;
+    void*              pixels;
+    cv::Mat* mat = (cv::Mat*) m;
+
+    if ( mat == 0 || mat->data == 0)
+        return false; // no native Mat behind
+
+    if ( AndroidBitmap_getInfo(env, bitmap, &info) < 0 )
+        return false; // can't get info
+
+    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
+        return false; // incompatible format
+
+    if ( AndroidBitmap_lockPixels(env, bitmap, &pixels) < 0 )
+        return false; // can't get pixels
+
+    if(mat->data && pixels)
+        memcpy(pixels, mat->data, info.height * info.width * 4);
+
+    AndroidBitmap_unlockPixels(env, bitmap);
+
+    return true;
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/modules/java/src/java/android+Utils.java b/modules/java/src/java/android+Utils.java
new file mode 100644
index 0000000000..6ffa2238df
--- /dev/null
+++ b/modules/java/src/java/android+Utils.java
@@ -0,0 +1,92 @@
+package org.opencv.android;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.highgui.Highgui;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Utils {
+
+    public static String exportResource(Context context, int resourceId) {
+        return exportResource(context, resourceId, "OpenCV_data");
+    }
+
+    public static String exportResource(Context context, int resourceId, String dirname) {
+        String fullname = context.getResources().getString(resourceId);
+        String resName = fullname.substring(fullname.lastIndexOf("/") + 1);
+        try {
+            InputStream is = context.getResources().openRawResource(resourceId);
+            File resDir = context.getDir(dirname, Context.MODE_PRIVATE);
+            File resFile = new File(resDir, resName);
+
+            FileOutputStream os = new FileOutputStream(resFile);
+
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while ((bytesRead = is.read(buffer)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            is.close();
+            os.close();
+
+            return resFile.getAbsolutePath();
+        } catch (IOException e) {
+            e.printStackTrace();
+            throw new CvException("Failed to export resource " + resName
+                    + ". Exception thrown: " + e);
+        }
+    }
+
+    public static Mat loadResource(Context context, int resourceId) throws IOException
+    {
+        return loadResource(context, resourceId, -1);
+    }
+
+    public static Mat loadResource(Context context, int resourceId, int flags) throws IOException
+    {
+        InputStream is = context.getResources().openRawResource(resourceId);
+        ByteArrayOutputStream os = new ByteArrayOutputStream(is.available());
+
+        byte[] buffer = new byte[4096];
+        int bytesRead;
+        while ((bytesRead = is.read(buffer)) != -1) {
+            os.write(buffer, 0, bytesRead);
+        }
+        is.close();
+
+        Mat encoded = new Mat(1, os.size(), CvType.CV_8U);
+        encoded.put(0, 0, os.toByteArray());
+        os.close();
+
+        Mat decoded = Highgui.imdecode(encoded, flags);
+        encoded.release();
+
+        return decoded;
+    }
+
+    public static Mat bitmapToMat(Bitmap b) {
+        return new Mat(nBitmapToMat(b));
+    }
+
+    public static boolean matToBitmap(Mat m, Bitmap b) {
+        return nMatToBitmap(m.nativeObj, b);
+    }
+
+    // native stuff
+    static {
+        System.loadLibrary("opencv_java");
+    }
+
+    private static native long nBitmapToMat(Bitmap b);
+
+    private static native boolean nMatToBitmap(long m, Bitmap b);
+}
diff --git a/modules/java/src/java/core+CvException.java b/modules/java/src/java/core+CvException.java
new file mode 100644
index 0000000000..ea00be13de
--- /dev/null
+++ b/modules/java/src/java/core+CvException.java
@@ -0,0 +1,15 @@
+package org.opencv.core;
+
+public class CvException extends RuntimeException {
+
+    private static final long serialVersionUID = 1L;
+
+    public CvException(String msg) {
+        super(msg);
+    }
+
+    @Override
+    public String toString() {
+        return "CvException [" + super.toString() + "]";
+    }
+}
diff --git a/modules/java/src/java/core+CvType.java b/modules/java/src/java/core+CvType.java
new file mode 100644
index 0000000000..003883a906
--- /dev/null
+++ b/modules/java/src/java/core+CvType.java
@@ -0,0 +1,136 @@
+package org.opencv.core;
+
+public final class CvType {
+
+    // type depth constants
+    public static final int
+            CV_8U = 0, CV_8S = 1,
+            CV_16U = 2, CV_16S = 3,
+            CV_32S = 4,
+            CV_32F = 5,
+            CV_64F = 6,
+            CV_USRTYPE1 = 7;
+
+    // predefined type constants
+    public static final int
+            CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),
+            CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),
+            CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),
+            CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),
+            CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),
+            CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),
+            CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);
+
+    private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);
+
+    public static final int makeType(int depth, int channels) {
+        if (channels <= 0 || channels >= CV_CN_MAX) {
+            throw new java.lang.UnsupportedOperationException(
+                    "Channels count should be 1.." + (CV_CN_MAX - 1));
+        }
+        if (depth < 0 || depth >= CV_DEPTH_MAX) {
+            throw new java.lang.UnsupportedOperationException(
+                    "Data type depth should be 0.." + (CV_DEPTH_MAX - 1));
+        }
+        return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT);
+    }
+
+    public static final int CV_8UC(int ch) {
+        return makeType(CV_8U, ch);
+    }
+
+    public static final int CV_8SC(int ch) {
+        return makeType(CV_8S, ch);
+    }
+
+    public static final int CV_16UC(int ch) {
+        return makeType(CV_16U, ch);
+    }
+
+    public static final int CV_16SC(int ch) {
+        return makeType(CV_16S, ch);
+    }
+
+    public static final int CV_32SC(int ch) {
+        return makeType(CV_32S, ch);
+    }
+
+    public static final int CV_32FC(int ch) {
+        return makeType(CV_32F, ch);
+    }
+
+    public static final int CV_64FC(int ch) {
+        return makeType(CV_64F, ch);
+    }
+
+    public static final int channels(int type) {
+        return (type >> CV_CN_SHIFT) + 1;
+    }
+
+    public static final int depth(int type) {
+        return type & (CV_DEPTH_MAX - 1);
+    }
+
+    public static final boolean isInteger(int type) {
+        return depth(type) < CV_32F;
+    }
+
+    public static final int ELEM_SIZE(int type) {
+        switch (depth(type)) {
+        case CV_8U:
+        case CV_8S:
+            return channels(type);
+        case CV_16U:
+        case CV_16S:
+            return 2 * channels(type);
+        case CV_32S:
+        case CV_32F:
+            return 4 * channels(type);
+        case CV_64F:
+            return 8 * channels(type);
+        default:
+            throw new java.lang.UnsupportedOperationException(
+                    "Unsupported CvType value: " + type);
+        }
+    }
+
+    public static final String typeToString(int type) {
+        String s;
+        switch (depth(type)) {
+        case CV_8U:
+            s = "CV_8U";
+            break;
+        case CV_8S:
+            s = "CV_8S";
+            break;
+        case CV_16U:
+            s = "CV_16U";
+            break;
+        case CV_16S:
+            s = "CV_16S";
+            break;
+        case CV_32S:
+            s = "CV_32S";
+            break;
+        case CV_32F:
+            s = "CV_32F";
+            break;
+        case CV_64F:
+            s = "CV_64F";
+            break;
+        case CV_USRTYPE1:
+            s = "CV_USRTYPE1";
+            break;
+        default:
+            throw new java.lang.UnsupportedOperationException(
+                    "Unsupported CvType value: " + type);
+        }
+
+        int ch = channels(type);
+        if (ch <= 4)
+            return s + "C" + ch;
+        else
+            return s + "C(" + ch + ")";
+    }
+
+}
diff --git a/modules/java/src/java/core+Mat.java b/modules/java/src/java/core+Mat.java
new file mode 100644
index 0000000000..3943380795
--- /dev/null
+++ b/modules/java/src/java/core+Mat.java
@@ -0,0 +1,1291 @@
+package org.opencv.core;
+
+// C++: class Mat
+//javadoc: Mat
+public class Mat {
+
+    public final long nativeObj;
+
+    public Mat(long addr)
+    {
+        if (addr == 0)
+            throw new java.lang.UnsupportedOperationException("Native object address is NULL");
+        nativeObj = addr;
+    }
+
+    //
+    // C++: Mat::Mat()
+    //
+
+    // javadoc: Mat::Mat()
+    public Mat()
+    {
+
+        nativeObj = n_Mat();
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(int rows, int cols, int type)
+    //
+
+    // javadoc: Mat::Mat(rows, cols, type)
+    public Mat(int rows, int cols, int type)
+    {
+
+        nativeObj = n_Mat(rows, cols, type);
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(Size size, int type)
+    //
+
+    // javadoc: Mat::Mat(size, type)
+    public Mat(Size size, int type)
+    {
+
+        nativeObj = n_Mat(size.width, size.height, type);
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(int rows, int cols, int type, Scalar s)
+    //
+
+    // javadoc: Mat::Mat(rows, cols, type, s)
+    public Mat(int rows, int cols, int type, Scalar s)
+    {
+
+        nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(Size size, int type, Scalar s)
+    //
+
+    // javadoc: Mat::Mat(size, type, s)
+    public Mat(Size size, int type, Scalar s)
+    {
+
+        nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
+    //
+
+    // javadoc: Mat::Mat(m, rowRange, colRange)
+    public Mat(Mat m, Range rowRange, Range colRange)
+    {
+
+        nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);
+
+        return;
+    }
+
+    // javadoc: Mat::Mat(m, rowRange)
+    public Mat(Mat m, Range rowRange)
+    {
+
+        nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);
+
+        return;
+    }
+
+    //
+    // C++: Mat::Mat(Mat m, Rect roi)
+    //
+
+    // javadoc: Mat::Mat(m, roi)
+    public Mat(Mat m, Rect roi)
+    {
+
+        nativeObj = n_Mat(m.nativeObj, roi.x, roi.x + roi.width, roi.y, roi.y + roi.height);
+
+        return;
+    }
+
+    //
+    // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
+    //
+
+    // javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)
+    public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)
+    {
+
+        Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));
+
+        return retVal;
+    }
+
+    //
+    // C++: void Mat::assignTo(Mat m, int type = -1)
+    //
+
+    // javadoc: Mat::assignTo(m, type)
+    public void assignTo(Mat m, int type)
+    {
+
+        n_assignTo(nativeObj, m.nativeObj, type);
+
+        return;
+    }
+
+    // javadoc: Mat::assignTo(m)
+    public void assignTo(Mat m)
+    {
+
+        n_assignTo(nativeObj, m.nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: int Mat::channels()
+    //
+
+    // javadoc: Mat::channels()
+    public int channels()
+    {
+
+        int retVal = n_channels(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
+    // requireContinuous = true)
+    //
+
+    // javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)
+    public int checkVector(int elemChannels, int depth, boolean requireContinuous)
+    {
+
+        int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);
+
+        return retVal;
+    }
+
+    // javadoc: Mat::checkVector(elemChannels, depth)
+    public int checkVector(int elemChannels, int depth)
+    {
+
+        int retVal = n_checkVector(nativeObj, elemChannels, depth);
+
+        return retVal;
+    }
+
+    // javadoc: Mat::checkVector(elemChannels)
+    public int checkVector(int elemChannels)
+    {
+
+        int retVal = n_checkVector(nativeObj, elemChannels);
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::clone()
+    //
+
+    // javadoc: Mat::clone()
+    public Mat clone()
+    {
+
+        Mat retVal = new Mat(n_clone(nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::col(int x)
+    //
+
+    // javadoc: Mat::col(x)
+    public Mat col(int x)
+    {
+
+        Mat retVal = new Mat(n_col(nativeObj, x));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::colRange(int startcol, int endcol)
+    //
+
+    // javadoc: Mat::colRange(startcol, endcol)
+    public Mat colRange(int startcol, int endcol)
+    {
+
+        Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::colRange(Range r)
+    //
+
+    // javadoc: Mat::colRange(r)
+    public Mat colRange(Range r)
+    {
+
+        Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));
+
+        return retVal;
+    }
+
+    //
+    // C++: int Mat::cols()
+    //
+
+    // javadoc: Mat::cols()
+    public int cols()
+    {
+
+        int retVal = n_cols(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
+    // = 0)
+    //
+
+    // javadoc: Mat::convertTo(m, rtype, alpha, beta)
+    public void convertTo(Mat m, int rtype, double alpha, double beta)
+    {
+
+        n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);
+
+        return;
+    }
+
+    // javadoc: Mat::convertTo(m, rtype, alpha)
+    public void convertTo(Mat m, int rtype, double alpha)
+    {
+
+        n_convertTo(nativeObj, m.nativeObj, rtype, alpha);
+
+        return;
+    }
+
+    // javadoc: Mat::convertTo(m, rtype)
+    public void convertTo(Mat m, int rtype)
+    {
+
+        n_convertTo(nativeObj, m.nativeObj, rtype);
+
+        return;
+    }
+
+    //
+    // C++: void Mat::copyTo(Mat& m)
+    //
+
+    // javadoc: Mat::copyTo(m)
+    public void copyTo(Mat m)
+    {
+
+        n_copyTo(nativeObj, m.nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: void Mat::copyTo(Mat& m, Mat mask)
+    //
+
+    // javadoc: Mat::copyTo(m, mask)
+    public void copyTo(Mat m, Mat mask)
+    {
+
+        n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: void Mat::create(int rows, int cols, int type)
+    //
+
+    // javadoc: Mat::create(rows, cols, type)
+    public void create(int rows, int cols, int type)
+    {
+
+        n_create(nativeObj, rows, cols, type);
+
+        return;
+    }
+
+    //
+    // C++: void Mat::create(Size size, int type)
+    //
+
+    // javadoc: Mat::create(size, type)
+    public void create(Size size, int type)
+    {
+
+        n_create(nativeObj, size.width, size.height, type);
+
+        return;
+    }
+
+    //
+    // C++: Mat Mat::cross(Mat m)
+    //
+
+    // javadoc: Mat::cross(m)
+    public Mat cross(Mat m)
+    {
+
+        Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: long Mat::dataAddr()
+    //
+
+    // javadoc: Mat::dataAddr()
+    public long dataAddr()
+    {
+
+        long retVal = n_dataAddr(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: int Mat::depth()
+    //
+
+    // javadoc: Mat::depth()
+    public int depth()
+    {
+
+        int retVal = n_depth(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::diag(int d = 0)
+    //
+
+    // javadoc: Mat::diag(d)
+    public Mat diag(int d)
+    {
+
+        Mat retVal = new Mat(n_diag(nativeObj, d));
+
+        return retVal;
+    }
+
+    // javadoc: Mat::diag()
+    public Mat diag()
+    {
+
+        Mat retVal = new Mat(n_diag(nativeObj, 0));
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::diag(Mat d)
+    //
+
+    // javadoc: Mat::diag(d)
+    public static Mat diag(Mat d)
+    {
+
+        Mat retVal = new Mat(n_diag(d.nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: double Mat::dot(Mat m)
+    //
+
+    // javadoc: Mat::dot(m)
+    public double dot(Mat m)
+    {
+
+        double retVal = n_dot(nativeObj, m.nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: size_t Mat::elemSize()
+    //
+
+    // javadoc: Mat::elemSize()
+    public long elemSize()
+    {
+
+        long retVal = n_elemSize(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: size_t Mat::elemSize1()
+    //
+
+    // javadoc: Mat::elemSize1()
+    public long elemSize1()
+    {
+
+        long retVal = n_elemSize1(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool Mat::empty()
+    //
+
+    // javadoc: Mat::empty()
+    public boolean empty()
+    {
+
+        boolean retVal = n_empty(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::eye(int rows, int cols, int type)
+    //
+
+    // javadoc: Mat::eye(rows, cols, type)
+    public static Mat eye(int rows, int cols, int type)
+    {
+
+        Mat retVal = new Mat(n_eye(rows, cols, type));
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::eye(Size size, int type)
+    //
+
+    // javadoc: Mat::eye(size, type)
+    public static Mat eye(Size size, int type)
+    {
+
+        Mat retVal = new Mat(n_eye(size.width, size.height, type));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::inv(int method = DECOMP_LU)
+    //
+
+    // javadoc: Mat::inv(method)
+    public Mat inv(int method)
+    {
+
+        Mat retVal = new Mat(n_inv(nativeObj, method));
+
+        return retVal;
+    }
+
+    // javadoc: Mat::inv()
+    public Mat inv()
+    {
+
+        Mat retVal = new Mat(n_inv(nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: bool Mat::isContinuous()
+    //
+
+    // javadoc: Mat::isContinuous()
+    public boolean isContinuous()
+    {
+
+        boolean retVal = n_isContinuous(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool Mat::isSubmatrix()
+    //
+
+    // javadoc: Mat::isSubmatrix()
+    public boolean isSubmatrix()
+    {
+
+        boolean retVal = n_isSubmatrix(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: void Mat::locateROI(Size wholeSize, Point ofs)
+    //
+
+    // javadoc: Mat::locateROI(wholeSize, ofs)
+    public void locateROI(Size wholeSize, Point ofs)
+    {
+        double[] wholeSize_out = new double[2];
+        double[] ofs_out = new double[2];
+        locateROI_0(nativeObj, wholeSize_out, ofs_out);
+        if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; } 
+        if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; } 
+        return;
+    }
+
+    //
+    // C++: Mat Mat::mul(Mat m, double scale = 1)
+    //
+
+    // javadoc: Mat::mul(m, scale)
+    public Mat mul(Mat m, double scale)
+    {
+
+        Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));
+
+        return retVal;
+    }
+
+    // javadoc: Mat::mul(m)
+    public Mat mul(Mat m)
+    {
+
+        Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::ones(int rows, int cols, int type)
+    //
+
+    // javadoc: Mat::ones(rows, cols, type)
+    public static Mat ones(int rows, int cols, int type)
+    {
+
+        Mat retVal = new Mat(n_ones(rows, cols, type));
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::ones(Size size, int type)
+    //
+
+    // javadoc: Mat::ones(size, type)
+    public static Mat ones(Size size, int type)
+    {
+
+        Mat retVal = new Mat(n_ones(size.width, size.height, type));
+
+        return retVal;
+    }
+
+    //
+    // C++: void Mat::push_back(Mat m)
+    //
+
+    // javadoc: Mat::push_back(m)
+    public void push_back(Mat m)
+    {
+
+        n_push_back(nativeObj, m.nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: void Mat::release()
+    //
+
+    // javadoc: Mat::release()
+    public void release()
+    {
+
+        n_release(nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: Mat Mat::reshape(int cn, int rows = 0)
+    //
+
+    // javadoc: Mat::reshape(cn, rows)
+    public Mat reshape(int cn, int rows)
+    {
+
+        Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));
+
+        return retVal;
+    }
+
+    // javadoc: Mat::reshape(cn)
+    public Mat reshape(int cn)
+    {
+
+        Mat retVal = new Mat(n_reshape(nativeObj, cn));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::row(int y)
+    //
+
+    // javadoc: Mat::row(y)
+    public Mat row(int y)
+    {
+
+        Mat retVal = new Mat(n_row(nativeObj, y));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::rowRange(int startrow, int endrow)
+    //
+
+    // javadoc: Mat::rowRange(startrow, endrow)
+    public Mat rowRange(int startrow, int endrow)
+    {
+
+        Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::rowRange(Range r)
+    //
+
+    // javadoc: Mat::rowRange(r)
+    public Mat rowRange(Range r)
+    {
+
+        Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));
+
+        return retVal;
+    }
+
+    //
+    // C++: int Mat::rows()
+    //
+
+    // javadoc: Mat::rows()
+    public int rows()
+    {
+
+        int retVal = n_rows(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::operator =(Scalar s)
+    //
+
+    // javadoc: Mat::operator =(s)
+    public Mat setTo(Scalar s)
+    {
+
+        Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
+    //
+
+    // javadoc: Mat::setTo(value, mask)
+    public Mat setTo(Mat value, Mat mask)
+    {
+
+        Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));
+
+        return retVal;
+    }
+
+    // javadoc: Mat::setTo(value)
+    public Mat setTo(Mat value)
+    {
+
+        Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: Size Mat::size()
+    //
+
+    // javadoc: Mat::size()
+    public Size size()
+    {
+
+        Size retVal = new Size(n_size(nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: size_t Mat::step1(int i = 0)
+    //
+
+    // javadoc: Mat::step1(i)
+    public long step1(int i)
+    {
+
+        long retVal = n_step1(nativeObj, i);
+
+        return retVal;
+    }
+
+    // javadoc: Mat::step1()
+    public long step1()
+    {
+
+        long retVal = n_step1(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int
+    // colEnd)
+    //
+
+    // javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)
+    public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)
+    {
+
+        Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::operator()(Range rowRange, Range colRange)
+    //
+
+    // javadoc: Mat::operator()(rowRange, colRange)
+    public Mat submat(Range rowRange, Range colRange)
+    {
+
+        Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::operator()(Rect roi)
+    //
+
+    // javadoc: Mat::operator()(roi)
+    public Mat submat(Rect roi)
+    {
+
+        Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));
+
+        return retVal;
+    }
+
+    //
+    // C++: Mat Mat::t()
+    //
+
+    // javadoc: Mat::t()
+    public Mat t()
+    {
+
+        Mat retVal = new Mat(n_t(nativeObj));
+
+        return retVal;
+    }
+
+    //
+    // C++: size_t Mat::total()
+    //
+
+    // javadoc: Mat::total()
+    public long total()
+    {
+
+        long retVal = n_total(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: int Mat::type()
+    //
+
+    // javadoc: Mat::type()
+    public int type()
+    {
+
+        int retVal = n_type(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::zeros(int rows, int cols, int type)
+    //
+
+    // javadoc: Mat::zeros(rows, cols, type)
+    public static Mat zeros(int rows, int cols, int type)
+    {
+
+        Mat retVal = new Mat(n_zeros(rows, cols, type));
+
+        return retVal;
+    }
+
+    //
+    // C++: static Mat Mat::zeros(Size size, int type)
+    //
+
+    // javadoc: Mat::zeros(size, type)
+    public static Mat zeros(Size size, int type)
+    {
+
+        Mat retVal = new Mat(n_zeros(size.width, size.height, type));
+
+        return retVal;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        n_delete(nativeObj);
+        super.finalize();
+    }
+
+    // javadoc:Mat::toString()
+    @Override
+    public String toString() {
+        return "Mat [ " +
+                rows() + "*" + cols() + "*" + CvType.typeToString(type()) +
+                ", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +
+                ", nativeObj=0x" + Long.toHexString(nativeObj) +
+                ", dataAddr=0x" + Long.toHexString(dataAddr()) +
+                " ]";
+    }
+
+    // javadoc:Mat::dump()
+    public String dump() {
+        return nDump(nativeObj);
+    }
+
+    // javadoc:Mat::put(row,col,data)
+    public int put(int row, int col, double... data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        return nPutD(nativeObj, row, col, data.length, data);
+    }
+
+    // javadoc:Mat::put(row,col,data)
+    public int put(int row, int col, float[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_32F) {
+            return nPutF(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::put(row,col,data)
+    public int put(int row, int col, int[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_32S) {
+            return nPutI(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::put(row,col,data)
+    public int put(int row, int col, short[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
+            return nPutS(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::put(row,col,data)
+    public int put(int row, int col, byte[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
+            return nPutB(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col,data)
+    public int get(int row, int col, byte[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {
+            return nGetB(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col,data)
+    public int get(int row, int col, short[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {
+            return nGetS(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col,data)
+    public int get(int row, int col, int[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_32S) {
+            return nGetI(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col,data)
+    public int get(int row, int col, float[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_32F) {
+            return nGetF(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col,data)
+    public int get(int row, int col, double[] data) {
+        int t = type();
+        if (data == null || data.length % CvType.channels(t) != 0)
+            throw new java.lang.UnsupportedOperationException(
+                    "Provided data element number (" +
+                            (data == null ? 0 : data.length) +
+                            ") should be multiple of the Mat channels count (" +
+                            CvType.channels(t) + ")");
+        if (CvType.depth(t) == CvType.CV_64F) {
+            return nGetD(nativeObj, row, col, data.length, data);
+        }
+        throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);
+    }
+
+    // javadoc:Mat::get(row,col)
+    public double[] get(int row, int col) {
+        return nGet(nativeObj, row, col);
+    }
+
+    // javadoc:Mat::height()
+    public int height() {
+        return rows();
+    }
+
+    // javadoc:Mat::width()
+    public int width() {
+        return cols();
+    }
+
+    // javadoc:Mat::getNativeObjAddr()
+    public long getNativeObjAddr() {
+        return nativeObj;
+    }
+
+    //
+    // native stuff
+    //
+    static {
+        System.loadLibrary("opencv_java");
+    }
+
+    // C++: Mat::Mat()
+    private static native long n_Mat();
+
+    // C++: Mat::Mat(int rows, int cols, int type)
+    private static native long n_Mat(int rows, int cols, int type);
+
+    // C++: Mat::Mat(Size size, int type)
+    private static native long n_Mat(double size_width, double size_height, int type);
+
+    // C++: Mat::Mat(int rows, int cols, int type, Scalar s)
+    private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3);
+
+    // C++: Mat::Mat(Size size, int type, Scalar s)
+    private static native long n_Mat(double size_width, double size_height, int type, double s_val0, double s_val1, double s_val2, double s_val3);
+
+    // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())
+    private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
+
+    private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);
+
+    // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)
+    private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);
+
+    // C++: void Mat::assignTo(Mat m, int type = -1)
+    private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);
+
+    private static native void n_assignTo(long nativeObj, long m_nativeObj);
+
+    // C++: int Mat::channels()
+    private static native int n_channels(long nativeObj);
+
+    // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool
+    // requireContinuous = true)
+    private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);
+
+    private static native int n_checkVector(long nativeObj, int elemChannels, int depth);
+
+    private static native int n_checkVector(long nativeObj, int elemChannels);
+
+    // C++: Mat Mat::clone()
+    private static native long n_clone(long nativeObj);
+
+    // C++: Mat Mat::col(int x)
+    private static native long n_col(long nativeObj, int x);
+
+    // C++: Mat Mat::colRange(int startcol, int endcol)
+    private static native long n_colRange(long nativeObj, int startcol, int endcol);
+
+    // C++: int Mat::cols()
+    private static native int n_cols(long nativeObj);
+
+    // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta
+    // = 0)
+    private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);
+
+    private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);
+
+    private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);
+
+    // C++: void Mat::copyTo(Mat& m)
+    private static native void n_copyTo(long nativeObj, long m_nativeObj);
+
+    // C++: void Mat::copyTo(Mat& m, Mat mask)
+    private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);
+
+    // C++: void Mat::create(int rows, int cols, int type)
+    private static native void n_create(long nativeObj, int rows, int cols, int type);
+
+    // C++: void Mat::create(Size size, int type)
+    private static native void n_create(long nativeObj, double size_width, double size_height, int type);
+
+    // C++: Mat Mat::cross(Mat m)
+    private static native long n_cross(long nativeObj, long m_nativeObj);
+
+    // C++: long Mat::dataAddr()
+    private static native long n_dataAddr(long nativeObj);
+
+    // C++: int Mat::depth()
+    private static native int n_depth(long nativeObj);
+
+    // C++: Mat Mat::diag(int d = 0)
+    private static native long n_diag(long nativeObj, int d);
+
+    // C++: static Mat Mat::diag(Mat d)
+    private static native long n_diag(long d_nativeObj);
+
+    // C++: double Mat::dot(Mat m)
+    private static native double n_dot(long nativeObj, long m_nativeObj);
+
+    // C++: size_t Mat::elemSize()
+    private static native long n_elemSize(long nativeObj);
+
+    // C++: size_t Mat::elemSize1()
+    private static native long n_elemSize1(long nativeObj);
+
+    // C++: bool Mat::empty()
+    private static native boolean n_empty(long nativeObj);
+
+    // C++: static Mat Mat::eye(int rows, int cols, int type)
+    private static native long n_eye(int rows, int cols, int type);
+
+    // C++: static Mat Mat::eye(Size size, int type)
+    private static native long n_eye(double size_width, double size_height, int type);
+
+    // C++: Mat Mat::inv(int method = DECOMP_LU)
+    private static native long n_inv(long nativeObj, int method);
+
+    private static native long n_inv(long nativeObj);
+
+    // C++: bool Mat::isContinuous()
+    private static native boolean n_isContinuous(long nativeObj);
+
+    // C++: bool Mat::isSubmatrix()
+    private static native boolean n_isSubmatrix(long nativeObj);
+
+    // C++: void Mat::locateROI(Size wholeSize, Point ofs)
+    private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out);
+
+    // C++: Mat Mat::mul(Mat m, double scale = 1)
+    private static native long n_mul(long nativeObj, long m_nativeObj, double scale);
+
+    private static native long n_mul(long nativeObj, long m_nativeObj);
+
+    // C++: static Mat Mat::ones(int rows, int cols, int type)
+    private static native long n_ones(int rows, int cols, int type);
+
+    // C++: static Mat Mat::ones(Size size, int type)
+    private static native long n_ones(double size_width, double size_height, int type);
+
+    // C++: void Mat::push_back(Mat m)
+    private static native void n_push_back(long nativeObj, long m_nativeObj);
+
+    // C++: void Mat::release()
+    private static native void n_release(long nativeObj);
+
+    // C++: Mat Mat::reshape(int cn, int rows = 0)
+    private static native long n_reshape(long nativeObj, int cn, int rows);
+
+    private static native long n_reshape(long nativeObj, int cn);
+
+    // C++: Mat Mat::row(int y)
+    private static native long n_row(long nativeObj, int y);
+
+    // C++: Mat Mat::rowRange(int startrow, int endrow)
+    private static native long n_rowRange(long nativeObj, int startrow, int endrow);
+
+    // C++: int Mat::rows()
+    private static native int n_rows(long nativeObj);
+
+    // C++: Mat Mat::operator =(Scalar s)
+    private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);
+
+    // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())
+    private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);
+
+    private static native long n_setTo(long nativeObj, long value_nativeObj);
+
+    // C++: Size Mat::size()
+    private static native double[] n_size(long nativeObj);
+
+    // C++: size_t Mat::step1(int i = 0)
+    private static native long n_step1(long nativeObj, int i);
+
+    private static native long n_step1(long nativeObj);
+
+    // C++: Mat Mat::operator()(Range rowRange, Range colRange)
+    private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);
+
+    // C++: Mat Mat::operator()(Rect roi)
+    private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);
+
+    // C++: Mat Mat::t()
+    private static native long n_t(long nativeObj);
+
+    // C++: size_t Mat::total()
+    private static native long n_total(long nativeObj);
+
+    // C++: int Mat::type()
+    private static native int n_type(long nativeObj);
+
+    // C++: static Mat Mat::zeros(int rows, int cols, int type)
+    private static native long n_zeros(int rows, int cols, int type);
+
+    // C++: static Mat Mat::zeros(Size size, int type)
+    private static native long n_zeros(double size_width, double size_height, int type);
+
+    // native support for java finalize()
+    private static native void n_delete(long nativeObj);
+
+    private static native int nPutD(long self, int row, int col, int count, double[] data);
+
+    private static native int nPutF(long self, int row, int col, int count, float[] data);
+
+    private static native int nPutI(long self, int row, int col, int count, int[] data);
+
+    private static native int nPutS(long self, int row, int col, int count, short[] data);
+
+    private static native int nPutB(long self, int row, int col, int count, byte[] data);
+
+    private static native int nGetB(long self, int row, int col, int count, byte[] vals);
+
+    private static native int nGetS(long self, int row, int col, int count, short[] vals);
+
+    private static native int nGetI(long self, int row, int col, int count, int[] vals);
+
+    private static native int nGetF(long self, int row, int col, int count, float[] vals);
+
+    private static native int nGetD(long self, int row, int col, int count, double[] vals);
+
+    private static native double[] nGet(long self, int row, int col);
+
+    private static native String nDump(long self);
+}
diff --git a/modules/java/src/java/core+Point.java b/modules/java/src/java/core+Point.java
new file mode 100644
index 0000000000..d850860f70
--- /dev/null
+++ b/modules/java/src/java/core+Point.java
@@ -0,0 +1,68 @@
+package org.opencv.core;
+
+//javadoc:Point_
+public class Point {
+
+    public double x, y;
+
+    public Point(double x, double y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Point() {
+        this(0, 0);
+    }
+
+    public Point(double[] vals) {
+        this();
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            x = vals.length > 0 ? vals[0] : 0;
+            y = vals.length > 1 ? vals[1] : 0;
+        } else {
+            x = 0;
+            y = 0;
+        }
+    }
+
+    public Point clone() {
+        return new Point(x, y);
+    }
+
+    public double dot(Point p) {
+        return x * p.x + y * p.y;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(x);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(y);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Point)) return false;
+        Point it = (Point) obj;
+        return x == it.x && y == it.y;
+    }
+
+    public boolean inside(Rect r) {
+        return r.contains(this);
+    }
+
+    @Override
+    public String toString() {
+        return "{" + x + ", " + y + "}";
+    }
+}
diff --git a/modules/java/src/java/core+Point3.java b/modules/java/src/java/core+Point3.java
new file mode 100644
index 0000000000..948a550f1d
--- /dev/null
+++ b/modules/java/src/java/core+Point3.java
@@ -0,0 +1,79 @@
+package org.opencv.core;
+
+//javadoc:Point3_
+public class Point3 {
+
+    public double x, y, z;
+
+    public Point3(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public Point3() {
+        this(0, 0, 0);
+    }
+
+    public Point3(Point p) {
+        x = p.x;
+        y = p.y;
+        z = 0;
+    }
+
+    public Point3(double[] vals) {
+        this();
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            x = vals.length > 0 ? vals[0] : 0;
+            y = vals.length > 1 ? vals[1] : 0;
+            z = vals.length > 2 ? vals[2] : 0;
+        } else {
+            x = 0;
+            y = 0;
+            z = 0;
+        }
+    }
+
+    public Point3 clone() {
+        return new Point3(x, y, z);
+    }
+
+    public double dot(Point3 p) {
+        return x * p.x + y * p.y + z * p.z;
+    }
+
+    public Point3 cross(Point3 p) {
+        return new Point3(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(x);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(y);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(z);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Point3)) return false;
+        Point3 it = (Point3) obj;
+        return x == it.x && y == it.y && z == it.z;
+    }
+    
+    @Override
+    public String toString() {
+        return "{" + x + ", " + y + ", " + z + "}";
+    }
+}
diff --git a/modules/java/src/java/core+Range.java b/modules/java/src/java/core+Range.java
new file mode 100644
index 0000000000..429ba7805a
--- /dev/null
+++ b/modules/java/src/java/core+Range.java
@@ -0,0 +1,82 @@
+package org.opencv.core;
+
+//javadoc:Range
+public class Range {
+
+    public int start, end;
+
+    public Range(int s, int e) {
+        this.start = s;
+        this.end = e;
+    }
+
+    public Range() {
+        this(0, 0);
+    }
+
+    public Range(double[] vals) {
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            start = vals.length > 0 ? (int) vals[0] : 0;
+            end = vals.length > 1 ? (int) vals[1] : 0;
+        } else {
+            start = 0;
+            end = 0;
+        }
+
+    }
+
+    public int size() {
+        return empty() ? 0 : end - start;
+    }
+
+    public boolean empty() {
+        return end <= start;
+    }
+
+    public static Range all() {
+        return new Range(Integer.MIN_VALUE, Integer.MAX_VALUE);
+    }
+
+    public Range intersection(Range r1) {
+        Range r = new Range(Math.max(r1.start, this.start), Math.min(r1.end, this.end));
+        r.end = Math.max(r.end, r.start);
+        return r;
+    }
+
+    public Range shift(int delta) {
+        return new Range(start + delta, end + delta);
+    }
+
+    public Range clone() {
+        return new Range(start, end);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(start);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(end);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Range)) return false;
+        Range it = (Range) obj;
+        return start == it.start && end == it.end;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + start + ", " + end + ")";
+    }
+}
diff --git a/modules/java/src/java/core+Rect.java b/modules/java/src/java/core+Rect.java
new file mode 100644
index 0000000000..a2c28bee74
--- /dev/null
+++ b/modules/java/src/java/core+Rect.java
@@ -0,0 +1,100 @@
+package org.opencv.core;
+
+//javadoc:Rect_
+public class Rect {
+
+    public int x, y, width, height;
+
+    public Rect(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public Rect() {
+        this(0, 0, 0, 0);
+    }
+
+    public Rect(Point p1, Point p2) {
+        x = (int) (p1.x < p2.x ? p1.x : p2.x);
+        y = (int) (p1.y < p2.y ? p1.y : p2.y);
+        width = (int) (p1.x > p2.x ? p1.x : p2.x) - x;
+        height = (int) (p1.y > p2.y ? p1.y : p2.y) - y;
+    }
+
+    public Rect(Point p, Size s) {
+        this((int) p.x, (int) p.y, (int) s.width, (int) s.height);
+    }
+
+    public Rect(double[] vals) {
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            x = vals.length > 0 ? (int) vals[0] : 0;
+            y = vals.length > 1 ? (int) vals[1] : 0;
+            width = vals.length > 2 ? (int) vals[2] : 0;
+            height = vals.length > 3 ? (int) vals[3] : 0;
+        } else {
+            x = 0;
+            y = 0;
+            width = 0;
+            height = 0;
+        }
+    }
+
+    public Rect clone() {
+        return new Rect(x, y, width, height);
+    }
+
+    public Point tl() {
+        return new Point(x, y);
+    }
+
+    public Point br() {
+        return new Point(x + width, y + height);
+    }
+
+    public Size size() {
+        return new Size(width, height);
+    }
+
+    public double area() {
+        return width * height;
+    }
+
+    public boolean contains(Point p) {
+        return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(height);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(width);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(x);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(y);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Rect)) return false;
+        Rect it = (Rect) obj;
+        return x == it.x && y == it.y && width == it.width && height == it.height;
+    }
+
+    @Override
+    public String toString() {
+        return "{" + x + ", " + y + ", " + width + "x" + height + "}";
+    }
+}
diff --git a/modules/java/src/java/core+RotatedRect.java b/modules/java/src/java/core+RotatedRect.java
new file mode 100644
index 0000000000..023a4cb695
--- /dev/null
+++ b/modules/java/src/java/core+RotatedRect.java
@@ -0,0 +1,113 @@
+package org.opencv.core;
+
+//javadoc:RotatedRect_
+public class RotatedRect {
+
+    public Point center;
+    public Size size;
+    public double angle;
+
+    public RotatedRect() {
+        this.center = new Point();
+        this.size = new Size();
+        this.angle = 0;
+    }
+
+    public RotatedRect(Point c, Size s, double a) {
+        this.center = c.clone();
+        this.size = s.clone();
+        this.angle = a;
+    }
+
+    public RotatedRect(double[] vals) {
+        this();
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            center.x = vals.length > 0 ? (double) vals[0] : 0;
+            center.y = vals.length > 1 ? (double) vals[1] : 0;
+            size.width = vals.length > 2 ? (double) vals[2] : 0;
+            size.height = vals.length > 3 ? (double) vals[3] : 0;
+            angle = vals.length > 4 ? (double) vals[4] : 0;
+        } else {
+            center.x = 0;
+            center.x = 0;
+            size.width = 0;
+            size.height = 0;
+            angle = 0;
+        }
+    }
+
+    public void points(Point pt[])
+    {
+        double _angle = angle * Math.PI / 180.0;
+        double b = (double) Math.cos(_angle) * 0.5f;
+        double a = (double) Math.sin(_angle) * 0.5f;
+
+        pt[0] = new Point(
+                center.x - a * size.height - b * size.width,
+                center.y + b * size.height - a * size.width);
+
+        pt[1] = new Point(
+                center.x + a * size.height - b * size.width,
+                center.y - b * size.height - a * size.width);
+
+        pt[2] = new Point(
+                2 * center.x - pt[0].x,
+                2 * center.y - pt[0].y);
+
+        pt[3] = new Point(
+                2 * center.x - pt[1].x,
+                2 * center.y - pt[1].y);
+    }
+
+    public Rect boundingRect()
+    {
+        Point pt[] = new Point[4];
+        points(pt);
+        Rect r = new Rect((int) Math.floor(Math.min(Math.min(Math.min(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
+                (int) Math.floor(Math.min(Math.min(Math.min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)),
+                (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
+                (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].y, pt[1].y), pt[2].y), pt[3].y)));
+        r.width -= r.x - 1;
+        r.height -= r.y - 1;
+        return r;
+    }
+
+    public RotatedRect clone() {
+        return new RotatedRect(center, size, angle);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(center.x);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(center.y);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(size.width);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(size.height);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(angle);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof RotatedRect)) return false;
+        RotatedRect it = (RotatedRect) obj;
+        return center.equals(it.center) && size.equals(it.size) && angle == it.angle;
+    }
+
+    @Override
+    public String toString() {
+        return "{ " + center + " " + size + " * " + angle + " }";
+    }
+}
diff --git a/modules/java/src/java/core+Scalar.java b/modules/java/src/java/core+Scalar.java
new file mode 100644
index 0000000000..72bfc58cf4
--- /dev/null
+++ b/modules/java/src/java/core+Scalar.java
@@ -0,0 +1,90 @@
+package org.opencv.core;
+
+//javadoc:Scalar_
+public class Scalar {
+
+    public double val[];
+
+    public Scalar(double v0, double v1, double v2, double v3) {
+        val = new double[] { v0, v1, v2, v3 };
+    }
+
+    public Scalar(double v0, double v1, double v2) {
+        val = new double[] { v0, v1, v2, 0 };
+    }
+
+    public Scalar(double v0, double v1) {
+        val = new double[] { v0, v1, 0, 0 };
+    }
+
+    public Scalar(double v0) {
+        val = new double[] { v0, 0, 0, 0 };
+    }
+
+    public Scalar(double[] vals) {
+        if (vals != null && vals.length == 4)
+            val = vals.clone();
+        else {
+            val = new double[4];
+            set(vals);
+        }
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            val[0] = vals.length > 0 ? vals[0] : 0;
+            val[1] = vals.length > 1 ? vals[1] : 0;
+            val[2] = vals.length > 2 ? vals[2] : 0;
+            val[3] = vals.length > 3 ? vals[3] : 0;
+        } else
+            val[0] = val[1] = val[2] = val[3] = 0;
+    }
+
+    public static Scalar all(double v) {
+        return new Scalar(v, v, v, v);
+    }
+
+    public Scalar clone() {
+        return new Scalar(val);
+    }
+
+    public Scalar mul(Scalar it, double scale) {
+        return new Scalar(val[0] * it.val[0] * scale, val[1] * it.val[1] * scale,
+                val[2] * it.val[2] * scale, val[3] * it.val[3] * scale);
+    }
+
+    public Scalar mul(Scalar it) {
+        return mul(it, 1);
+    }
+
+    public Scalar conj() {
+        return new Scalar(val[0], -val[1], -val[2], -val[3]);
+    }
+
+    public boolean isReal() {
+        return val[1] == 0 && val[2] == 0 && val[3] == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + java.util.Arrays.hashCode(val);
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Scalar)) return false;
+        Scalar it = (Scalar) obj;
+        if (!java.util.Arrays.equals(val, it.val)) return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + val[0] + ", " + val[1] + ", " + val[2] + ", " + val[3] + "]";
+    }
+
+}
diff --git a/modules/java/src/java/core+Size.java b/modules/java/src/java/core+Size.java
new file mode 100644
index 0000000000..5747a43a58
--- /dev/null
+++ b/modules/java/src/java/core+Size.java
@@ -0,0 +1,69 @@
+package org.opencv.core;
+
+//javadoc:Size_
+public class Size {
+
+    public double width, height;
+
+    public Size(double width, double height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    public Size() {
+        this(0, 0);
+    }
+
+    public Size(Point p) {
+        width = p.x;
+        height = p.y;
+    }
+
+    public Size(double[] vals) {
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            width = vals.length > 0 ? vals[0] : 0;
+            height = vals.length > 1 ? vals[1] : 0;
+        } else {
+            width = 0;
+            height = 0;
+        }
+    }
+
+    public double area() {
+        return width * height;
+    }
+
+    public Size clone() {
+        return new Size(width, height);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(height);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(width);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Size)) return false;
+        Size it = (Size) obj;
+        return width == it.width && height == it.height;
+    }
+
+    @Override
+    public String toString() {
+        return (int)width + "x" + (int)height;
+    }
+
+}
diff --git a/modules/java/src/java/core+TermCriteria.java b/modules/java/src/java/core+TermCriteria.java
new file mode 100644
index 0000000000..1717883d16
--- /dev/null
+++ b/modules/java/src/java/core+TermCriteria.java
@@ -0,0 +1,93 @@
+package org.opencv.core;
+
+//javadoc:TermCriteria
+public class TermCriteria {
+
+    /**
+     * the maximum number of iterations or elements to compute
+     */
+    public static final int COUNT = 1;
+    /**
+     * the maximum number of iterations or elements to compute
+     */
+    public static final int MAX_ITER = COUNT;
+    /**
+     * the desired accuracy or change in parameters at which the iterative algorithm stops
+     */
+    public static final int EPS = 2;
+
+    public int type;
+    public int maxCount;
+    public double epsilon;
+
+    /**
+     * Termination criteria in iterative algorithms
+     * 
+     * @param type
+     *            the type of termination criteria: COUNT, EPS or COUNT + EPS
+     * @param maxCount
+     *            the maximum number of iterations/elements
+     * @param epsilon
+     *            the desired accuracy
+     */
+    public TermCriteria(int type, int maxCount, double epsilon) {
+        this.type = type;
+        this.maxCount = maxCount;
+        this.epsilon = epsilon;
+    }
+
+    /**
+     * Termination criteria in iterative algorithms
+     */
+    public TermCriteria() {
+        this(0, 0, 0.0);
+    }
+
+    public TermCriteria(double[] vals) {
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            type = vals.length > 0 ? (int) vals[0] : 0;
+            maxCount = vals.length > 1 ? (int) vals[1] : 0;
+            epsilon = vals.length > 2 ? (double) vals[2] : 0;
+        } else {
+            type = 0;
+            maxCount = 0;
+            epsilon = 0;
+        }
+    }
+
+    public TermCriteria clone() {
+        return new TermCriteria(type, maxCount, epsilon);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(type);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(maxCount);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(epsilon);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof TermCriteria)) return false;
+        TermCriteria it = (TermCriteria) obj;
+        return type == it.type && maxCount == it.maxCount && epsilon == it.epsilon;
+    }
+
+    @Override
+    public String toString() {
+        if (this == null) return "null";
+        return "{ type: " + type + ", maxCount: " + maxCount + ", epsilon: " + epsilon + "}";
+    }
+}
diff --git a/modules/java/src/java/features2d+DMatch.java b/modules/java/src/java/features2d+DMatch.java
new file mode 100644
index 0000000000..ac864063ef
--- /dev/null
+++ b/modules/java/src/java/features2d+DMatch.java
@@ -0,0 +1,61 @@
+package org.opencv.features2d;
+
+//C++: class DMatch
+
+/**
+ * Struct for matching: query descriptor index, train descriptor index, train
+ * image index and distance between descriptors.
+ */
+public class DMatch {
+
+    /**
+     * query descriptor index
+     */
+    public int queryIdx;
+    /**
+     * train descriptor index
+     */
+    public int trainIdx;
+    /**
+     * train image index
+     */
+    public int imgIdx;
+
+    // javadoc: DMatch::distance
+    public float distance;
+
+    // javadoc: DMatch::DMatch()
+    public DMatch() {
+        this(-1, -1, Float.MAX_VALUE);
+    }
+
+    // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _distance)
+    public DMatch(int _queryIdx, int _trainIdx, float _distance) {
+        queryIdx = _queryIdx;
+        trainIdx = _trainIdx;
+        imgIdx = -1;
+        distance = _distance;
+    }
+
+    // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance)
+    public DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {
+        queryIdx = _queryIdx;
+        trainIdx = _trainIdx;
+        imgIdx = _imgIdx;
+        distance = _distance;
+    }
+
+    /**
+     * less is better
+     */
+    public boolean lessThan(DMatch it) {
+        return distance < it.distance;
+    }
+
+    @Override
+    public String toString() {
+        return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx
+                + ", imgIdx=" + imgIdx + ", distance=" + distance + "]";
+    }
+
+}
diff --git a/modules/java/src/java/features2d+KeyPoint.java b/modules/java/src/java/features2d+KeyPoint.java
new file mode 100644
index 0000000000..f141cd16f7
--- /dev/null
+++ b/modules/java/src/java/features2d+KeyPoint.java
@@ -0,0 +1,83 @@
+package org.opencv.features2d;
+
+import org.opencv.core.Point;
+
+//javadoc: KeyPoint
+public class KeyPoint {
+
+    /**
+     * coordinates of the keypoint
+     */
+    public Point pt;
+    /**
+     * diameter of the meaningful keypoint neighborhood
+     */
+    public float size;
+    /**
+     * computed orientation of the keypoint (-1 if not applicable)
+     */
+    public float angle;
+    /**
+     * the response by which the most strong keypoints have been selected. Can
+     * be used for further sorting or subsampling
+     */
+    public float response;
+    /**
+     * octave (pyramid layer) from which the keypoint has been extracted
+     */
+    public int octave;
+    /**
+     * object id that can be used to clustered keypoints by an object they
+     * belong to
+     */
+    public int class_id;
+
+    // javadoc:KeyPoint::KeyPoint(x,y,_size,_angle,_response,_octave,_class_id)
+    public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
+    {
+        pt = new Point(x, y);
+        size = _size;
+        angle = _angle;
+        response = _response;
+        octave = _octave;
+        class_id = _class_id;
+    }
+
+    // javadoc: KeyPoint::KeyPoint()
+    public KeyPoint()
+    {
+        this(0, 0, 0, -1, 0, 0, -1);
+    }
+
+    // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave)
+    public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave)
+    {
+        this(x, y, _size, _angle, _response, _octave, -1);
+    }
+
+    // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response)
+    public KeyPoint(float x, float y, float _size, float _angle, float _response)
+    {
+        this(x, y, _size, _angle, _response, 0, -1);
+    }
+
+    // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle)
+    public KeyPoint(float x, float y, float _size, float _angle)
+    {
+        this(x, y, _size, _angle, 0, 0, -1);
+    }
+
+    // javadoc: KeyPoint::KeyPoint(x, y, _size)
+    public KeyPoint(float x, float y, float _size)
+    {
+        this(x, y, _size, -1, 0, 0, -1);
+    }
+
+    @Override
+    public String toString() {
+        return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle
+                + ", response=" + response + ", octave=" + octave
+                + ", class_id=" + class_id + "]";
+    }
+
+}
diff --git a/modules/java/src/java/highgui+VideoCapture.java b/modules/java/src/java/highgui+VideoCapture.java
new file mode 100644
index 0000000000..9540f58e81
--- /dev/null
+++ b/modules/java/src/java/highgui+VideoCapture.java
@@ -0,0 +1,246 @@
+package org.opencv.highgui;
+
+import java.util.List;
+import java.util.LinkedList;
+
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+
+// C++: class VideoCapture
+//javadoc: VideoCapture
+public class VideoCapture {
+
+    protected final long nativeObj;
+
+    protected VideoCapture(long addr) {
+        nativeObj = addr;
+    }
+
+    //
+    // C++: VideoCapture::VideoCapture()
+    //
+
+    // javadoc: VideoCapture::VideoCapture()
+    public VideoCapture()
+    {
+
+        nativeObj = n_VideoCapture();
+
+        return;
+    }
+
+    //
+    // C++: VideoCapture::VideoCapture(int device)
+    //
+
+    // javadoc: VideoCapture::VideoCapture(device)
+    public VideoCapture(int device)
+    {
+
+        nativeObj = n_VideoCapture(device);
+
+        return;
+    }
+
+    //
+    // C++: double VideoCapture::get(int propId)
+    //
+
+/**
+ * Returns the specified "VideoCapture" property
+ *
+ * Note: When querying a property that is not supported by the backend used by
+ * the "VideoCapture" class, value 0 is returned.
+ *
+ * @param propId Property identifier. It can be one of the following:
+ *   * CV_CAP_PROP_FRAME_WIDTH Width of the frames in the video stream.
+ *   * CV_CAP_PROP_FRAME_HEIGHT Height of the frames in the video stream.
+ *
+ * @see <a href="http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-get">org.opencv.highgui.VideoCapture.get</a>
+ */
+    public double get(int propId)
+    {
+
+        double retVal = n_get(nativeObj, propId);
+
+        return retVal;
+    }
+
+    public List<Size> getSupportedPreviewSizes()
+    {
+        String[] sizes_str = n_getSupportedPreviewSizes(nativeObj).split(",");
+        List<Size> sizes = new LinkedList<Size>();
+
+        for (String str : sizes_str) {
+            String[] wh = str.split("x");
+            sizes.add(new Size(Double.parseDouble(wh[0]), Double.parseDouble(wh[1])));
+        }
+
+        return sizes;
+    }
+
+    //
+    // C++: bool VideoCapture::grab()
+    //
+
+    // javadoc: VideoCapture::grab()
+    public boolean grab()
+    {
+
+        boolean retVal = n_grab(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::isOpened()
+    //
+
+    // javadoc: VideoCapture::isOpened()
+    public boolean isOpened()
+    {
+
+        boolean retVal = n_isOpened(nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::open(int device)
+    //
+
+    // javadoc: VideoCapture::open(device)
+    public boolean open(int device)
+    {
+
+        boolean retVal = n_open(nativeObj, device);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::read(Mat image)
+    //
+
+    // javadoc: VideoCapture::read(image)
+    public boolean read(Mat image)
+    {
+
+        boolean retVal = n_read(nativeObj, image.nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: void VideoCapture::release()
+    //
+
+    // javadoc: VideoCapture::release()
+    public void release()
+    {
+
+        n_release(nativeObj);
+
+        return;
+    }
+
+    //
+    // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+    //
+
+    // javadoc: VideoCapture::retrieve(image, channel)
+    public boolean retrieve(Mat image, int channel)
+    {
+
+        boolean retVal = n_retrieve(nativeObj, image.nativeObj, channel);
+
+        return retVal;
+    }
+
+    // javadoc: VideoCapture::retrieve(image)
+    public boolean retrieve(Mat image)
+    {
+
+        boolean retVal = n_retrieve(nativeObj, image.nativeObj);
+
+        return retVal;
+    }
+
+    //
+    // C++: bool VideoCapture::set(int propId, double value)
+    //
+
+/**
+ * Sets a property in the "VideoCapture".
+ *
+ * @param propId Property identifier. It can be one of the following:
+ *   * CV_CAP_PROP_FRAME_WIDTH Width of the frames in the video stream.
+ *   * CV_CAP_PROP_FRAME_HEIGHT Height of the frames in the video stream.
+ * @param value Value of the property.
+ *
+ * @see <a href="http://opencv.itseez.com/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-set">org.opencv.highgui.VideoCapture.set</a>
+ */
+    public boolean set(int propId, double value)
+    {
+
+        boolean retVal = n_set(nativeObj, propId, value);
+
+        return retVal;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        n_delete(nativeObj);
+        super.finalize();
+    }
+
+    // native stuff
+
+    static {
+        System.loadLibrary("opencv_java");
+    }
+
+    // C++: VideoCapture::VideoCapture()
+    private static native long n_VideoCapture();
+
+    // C++: VideoCapture::VideoCapture(string filename)
+    private static native long n_VideoCapture(java.lang.String filename);
+
+    // C++: VideoCapture::VideoCapture(int device)
+    private static native long n_VideoCapture(int device);
+
+    // C++: double VideoCapture::get(int propId)
+    private static native double n_get(long nativeObj, int propId);
+
+    // C++: bool VideoCapture::grab()
+    private static native boolean n_grab(long nativeObj);
+
+    // C++: bool VideoCapture::isOpened()
+    private static native boolean n_isOpened(long nativeObj);
+
+    // C++: bool VideoCapture::open(string filename)
+    private static native boolean n_open(long nativeObj, java.lang.String filename);
+
+    // C++: bool VideoCapture::open(int device)
+    private static native boolean n_open(long nativeObj, int device);
+
+    // C++: bool VideoCapture::read(Mat image)
+    private static native boolean n_read(long nativeObj, long image_nativeObj);
+
+    // C++: void VideoCapture::release()
+    private static native void n_release(long nativeObj);
+
+    // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+    private static native boolean n_retrieve(long nativeObj, long image_nativeObj, int channel);
+
+    private static native boolean n_retrieve(long nativeObj, long image_nativeObj);
+
+    // C++: bool VideoCapture::set(int propId, double value)
+    private static native boolean n_set(long nativeObj, int propId, double value);
+
+    private static native String n_getSupportedPreviewSizes(long nativeObj);
+
+    // native support for java finalize()
+    private static native void n_delete(long nativeObj);
+
+}
diff --git a/modules/java/src/java/utils+Converters.java b/modules/java/src/java/utils+Converters.java
new file mode 100644
index 0000000000..21bb92bd1d
--- /dev/null
+++ b/modules/java/src/java/utils+Converters.java
@@ -0,0 +1,646 @@
+package org.opencv.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opencv.core.Mat;
+import org.opencv.core.CvType;
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.core.Rect;
+import org.opencv.features2d.DMatch;
+import org.opencv.features2d.KeyPoint;
+
+public class Converters {
+
+    public static Mat vector_Point_to_Mat(List<Point> pts) {
+        return vector_Point_to_Mat(pts, CvType.CV_32S);
+    }
+
+    public static Mat vector_Point2f_to_Mat(List<Point> pts) {
+        return vector_Point_to_Mat(pts, CvType.CV_32F);
+    }
+
+    public static Mat vector_Point2d_to_Mat(List<Point> pts) {
+        return vector_Point_to_Mat(pts, CvType.CV_64F);
+    }
+
+    public static Mat vector_Point_to_Mat(List<Point> pts, int typeDepth) {
+        Mat res;
+        int count = (pts != null) ? pts.size() : 0;
+        if (count > 0) {
+            switch (typeDepth) {
+            case CvType.CV_32S: {
+                res = new Mat(count, 1, CvType.CV_32SC2);
+                int[] buff = new int[count * 2];
+                for (int i = 0; i < count; i++) {
+                    Point p = pts.get(i);
+                    buff[i * 2] = (int) p.x;
+                    buff[i * 2 + 1] = (int) p.y;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            case CvType.CV_32F: {
+                res = new Mat(count, 1, CvType.CV_32FC2);
+                float[] buff = new float[count * 2];
+                for (int i = 0; i < count; i++) {
+                    Point p = pts.get(i);
+                    buff[i * 2] = (float) p.x;
+                    buff[i * 2 + 1] = (float) p.y;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            case CvType.CV_64F: {
+                res = new Mat(count, 1, CvType.CV_64FC2);
+                double[] buff = new double[count * 2];
+                for (int i = 0; i < count; i++) {
+                    Point p = pts.get(i);
+                    buff[i * 2] = p.x;
+                    buff[i * 2 + 1] = p.y;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            default:
+                throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
+            }
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static Mat vector_Point3i_to_Mat(List<Point3> pts) {
+        return vector_Point3_to_Mat(pts, CvType.CV_32S);
+    }
+
+    public static Mat vector_Point3f_to_Mat(List<Point3> pts) {
+        return vector_Point3_to_Mat(pts, CvType.CV_32F);
+    }
+
+    public static Mat vector_Point3d_to_Mat(List<Point3> pts) {
+        return vector_Point3_to_Mat(pts, CvType.CV_64F);
+    }
+
+    public static Mat vector_Point3_to_Mat(List<Point3> pts, int typeDepth) {
+        Mat res;
+        int count = (pts != null) ? pts.size() : 0;
+        if (count > 0) {
+            switch (typeDepth) {
+            case CvType.CV_32S: {
+                res = new Mat(count, 1, CvType.CV_32SC3);
+                int[] buff = new int[count * 3];
+                for (int i = 0; i < count; i++) {
+                    Point3 p = pts.get(i);
+                    buff[i * 3] = (int) p.x;
+                    buff[i * 3 + 1] = (int) p.y;
+                    buff[i * 3 + 2] = (int) p.z;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            case CvType.CV_32F: {
+                res = new Mat(count, 1, CvType.CV_32FC3);
+                float[] buff = new float[count * 3];
+                for (int i = 0; i < count; i++) {
+                    Point3 p = pts.get(i);
+                    buff[i * 3] = (float) p.x;
+                    buff[i * 3 + 1] = (float) p.y;
+                    buff[i * 3 + 2] = (float) p.z;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            case CvType.CV_64F: {
+                res = new Mat(count, 1, CvType.CV_64FC3);
+                double[] buff = new double[count * 3];
+                for (int i = 0; i < count; i++) {
+                    Point3 p = pts.get(i);
+                    buff[i * 3] = p.x;
+                    buff[i * 3 + 1] = p.y;
+                    buff[i * 3 + 2] = p.z;
+                }
+                res.put(0, 0, buff);
+            }
+                break;
+
+            default:
+                throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");
+            }
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_Point2f(Mat m, List<Point> pts) {
+        Mat_to_vector_Point(m, pts);
+    }
+
+    public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) {
+        Mat_to_vector_Point(m, pts);
+    }
+
+    public static void Mat_to_vector_Point(Mat m, List<Point> pts) {
+        if (pts == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        int type = m.type();
+        if (m.cols() != 1)
+            throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);
+
+        pts.clear();
+        if (type == CvType.CV_32SC2) {
+            int[] buff = new int[2 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
+            }
+        } else if (type == CvType.CV_32FC2) {
+            float[] buff = new float[2 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
+            }
+        } else if (type == CvType.CV_64FC2) {
+            double[] buff = new double[2 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));
+            }
+        } else {
+            throw new java.lang.IllegalArgumentException(
+                    "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m);
+        }
+    }
+
+    public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) {
+        Mat_to_vector_Point3(m, pts);
+    }
+
+    public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) {
+        Mat_to_vector_Point3(m, pts);
+    }
+
+    public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) {
+        Mat_to_vector_Point3(m, pts);
+    }
+
+    public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) {
+        if (pts == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        int type = m.type();
+        if (m.cols() != 1)
+            throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);
+
+        pts.clear();
+        if (type == CvType.CV_32SC3) {
+            int[] buff = new int[3 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
+            }
+        } else if (type == CvType.CV_32FC3) {
+            float[] buff = new float[3 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
+            }
+        } else if (type == CvType.CV_64FC3) {
+            double[] buff = new double[3 * count];
+            m.get(0, 0, buff);
+            for (int i = 0; i < count; i++) {
+                pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));
+            }
+        } else {
+            throw new java.lang.IllegalArgumentException(
+                    "Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m);
+        }
+    }
+
+    public static Mat vector_Mat_to_Mat(List<Mat> mats) {
+        Mat res;
+        int count = (mats != null) ? mats.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_32SC2);
+            int[] buff = new int[count * 2];
+            for (int i = 0; i < count; i++) {
+                long addr = mats.get(i).nativeObj;
+                buff[i * 2] = (int) (addr >> 32);
+                buff[i * 2 + 1] = (int) (addr & 0xffffffff);
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_Mat(Mat m, List<Mat> mats) {
+        if (mats == null)
+            throw new java.lang.IllegalArgumentException("mats == null");
+        int count = m.rows();
+        if (CvType.CV_32SC2 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_32SC2 != m.type() ||  m.cols()!=1\n" + m);
+
+        mats.clear();
+        int[] buff = new int[count * 2];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            long addr = (((long) buff[i * 2]) << 32) | ((long) buff[i * 2 + 1]);
+            mats.add(new Mat(addr));
+        }
+    }
+
+    public static Mat vector_float_to_Mat(List<Float> fs) {
+        Mat res;
+        int count = (fs != null) ? fs.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_32FC1);
+            float[] buff = new float[count];
+            for (int i = 0; i < count; i++) {
+                float f = fs.get(i);
+                buff[i] = f;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_float(Mat m, List<Float> fs) {
+        if (fs == null)
+            throw new java.lang.IllegalArgumentException("fs == null");
+        int count = m.rows();
+        if (CvType.CV_32FC1 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_32FC1 != m.type() ||  m.cols()!=1\n" + m);
+
+        fs.clear();
+        float[] buff = new float[count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            fs.add(buff[i]);
+        }
+    }
+
+    public static Mat vector_uchar_to_Mat(List<Byte> bs) {
+        Mat res;
+        int count = (bs != null) ? bs.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_8UC1);
+            byte[] buff = new byte[count];
+            for (int i = 0; i < count; i++) {
+                byte b = bs.get(i);
+                buff[i] = b;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_uchar(Mat m, List<Byte> us) {
+        if (us == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        if (CvType.CV_8UC1 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_8UC1 != m.type() ||  m.cols()!=1\n" + m);
+
+        us.clear();
+        byte[] buff = new byte[count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            us.add(buff[i]);
+        }
+    }
+
+    public static Mat vector_char_to_Mat(List<Byte> bs) {
+        Mat res;
+        int count = (bs != null) ? bs.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_8SC1);
+            byte[] buff = new byte[count];
+            for (int i = 0; i < count; i++) {
+                byte b = bs.get(i);
+                buff[i] = b;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static Mat vector_int_to_Mat(List<Integer> is) {
+        Mat res;
+        int count = (is != null) ? is.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_32SC1);
+            int[] buff = new int[count];
+            for (int i = 0; i < count; i++) {
+                int v = is.get(i);
+                buff[i] = v;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_int(Mat m, List<Integer> is) {
+        if (is == null)
+            throw new java.lang.IllegalArgumentException("is == null");
+        int count = m.rows();
+        if (CvType.CV_32SC1 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_32SC1 != m.type() ||  m.cols()!=1\n" + m);
+
+        is.clear();
+        int[] buff = new int[count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            is.add(buff[i]);
+        }
+    }
+
+    public static void Mat_to_vector_char(Mat m, List<Byte> bs) {
+        if (bs == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        if (CvType.CV_8SC1 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_8SC1 != m.type() ||  m.cols()!=1\n" + m);
+
+        bs.clear();
+        byte[] buff = new byte[count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            bs.add(buff[i]);
+        }
+    }
+
+    public static Mat vector_Rect_to_Mat(List<Rect> rs) {
+        Mat res;
+        int count = (rs != null) ? rs.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_32SC4);
+            int[] buff = new int[4 * count];
+            for (int i = 0; i < count; i++) {
+                Rect r = rs.get(i);
+                buff[4 * i] = r.x;
+                buff[4 * i + 1] = r.y;
+                buff[4 * i + 2] = r.width;
+                buff[4 * i + 3] = r.height;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_Rect(Mat m, List<Rect> rs) {
+        if (rs == null)
+            throw new java.lang.IllegalArgumentException("rs == null");
+        int count = m.rows();
+        if (CvType.CV_32SC4 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_32SC4 != m.type() ||  m.rows()!=1\n" + m);
+
+        rs.clear();
+        int[] buff = new int[4 * count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3]));
+        }
+    }
+
+    public static Mat vector_KeyPoint_to_Mat(List<KeyPoint> kps) {
+        Mat res;
+        int count = (kps != null) ? kps.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_64FC(7));
+            double[] buff = new double[count * 7];
+            for (int i = 0; i < count; i++) {
+                KeyPoint kp = kps.get(i);
+                buff[7 * i] = kp.pt.x;
+                buff[7 * i + 1] = kp.pt.y;
+                buff[7 * i + 2] = kp.size;
+                buff[7 * i + 3] = kp.angle;
+                buff[7 * i + 4] = kp.response;
+                buff[7 * i + 5] = kp.octave;
+                buff[7 * i + 6] = kp.class_id;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_KeyPoint(Mat m, List<KeyPoint> kps) {
+        if (kps == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        if (CvType.CV_64FC(7) != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_64FC(7) != m.type() ||  m.cols()!=1\n" + m);
+
+        kps.clear();
+        double[] buff = new double[7 * count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3],
+                    (float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6]));
+        }
+    }
+	
+    // vector_vector_Point
+    public static Mat vector_vector_Point_to_Mat(List<List<Point>> pts, List<Mat> mats) {
+        Mat res;
+        int lCount = (pts != null) ? pts.size() : 0;
+        if (lCount > 0) {
+            for (List<Point> lpt : pts)
+                mats.add(vector_Point_to_Mat(lpt));
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    // vector_vector_Point2f
+    public static void Mat_to_vector_vector_Point2f(Mat m, List<List<Point>> pts) {
+        if (pts == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+
+        if (m == null)
+            throw new java.lang.IllegalArgumentException("Input Mat can't be null");
+
+        List<Mat> mats = new ArrayList<Mat>(m.rows());
+        Mat_to_vector_Mat(m, mats);
+        List<Point> pt = new ArrayList<Point>();
+        for (Mat mi : mats) {
+            Mat_to_vector_Point2f(mi, pt);
+            pts.add(pt);
+        }
+    }
+
+    // vector_vector_KeyPoint
+    public static Mat vector_vector_KeyPoint_to_Mat(List<List<KeyPoint>> kps, List<Mat> mats) {
+        Mat res;
+        int lCount = (kps != null) ? kps.size() : 0;
+        if (lCount > 0) {
+            for (List<KeyPoint> lkp : kps)
+                mats.add(vector_KeyPoint_to_Mat(lkp));
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_vector_KeyPoint(Mat m, List<List<KeyPoint>> kps) {
+        if (kps == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+
+        if (m == null)
+            throw new java.lang.IllegalArgumentException("Input Mat can't be null");
+
+        List<Mat> mats = new ArrayList<Mat>(m.rows());
+        Mat_to_vector_Mat(m, mats);
+        List<KeyPoint> lkp = new ArrayList<KeyPoint>();
+        for (Mat mi : mats) {
+            Mat_to_vector_KeyPoint(mi, lkp);
+            kps.add(lkp);
+        }
+    }
+
+    public static Mat vector_double_to_Mat(List<Double> ds) {
+        Mat res;
+        int count = (ds != null) ? ds.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_64FC1);
+            double[] buff = new double[count];
+            for (int i = 0; i < count; i++) {
+                double v = ds.get(i);
+                buff[i] = v;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static Mat vector_DMatch_to_Mat(List<DMatch> matches) {
+        Mat res;
+        int count = (matches != null) ? matches.size() : 0;
+        if (count > 0) {
+            res = new Mat(count, 1, CvType.CV_64FC4);
+            double[] buff = new double[count * 4];
+            for (int i = 0; i < count; i++) {
+                DMatch m = matches.get(i);
+                buff[4 * i] = m.queryIdx;
+                buff[4 * i + 1] = m.trainIdx;
+                buff[4 * i + 2] = m.imgIdx;
+                buff[4 * i + 3] = m.distance;
+            }
+            res.put(0, 0, buff);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_DMatch(Mat m, List<DMatch> matches) {
+        if (matches == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+        int count = m.rows();
+        if (CvType.CV_64FC4 != m.type() || m.cols() != 1)
+            throw new java.lang.IllegalArgumentException(
+                    "CvType.CV_64FC4 != m.type() ||  m.cols()!=1\n" + m);
+
+        matches.clear();
+        double[] buff = new double[4 * count];
+        m.get(0, 0, buff);
+        for (int i = 0; i < count; i++) {
+            matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3]));
+        }
+    }
+
+    // vector_vector_DMatch
+    public static Mat vector_vector_DMatch_to_Mat(List<List<DMatch>> lldm, List<Mat> mats) {
+        Mat res;
+        int lCount = (lldm != null) ? lldm.size() : 0;
+        if (lCount > 0) {
+            for (List<DMatch> ldm : lldm)
+                mats.add(vector_DMatch_to_Mat(ldm));
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_vector_DMatch(Mat m, List<List<DMatch>> lldm) {
+        if (lldm == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+
+        if (m == null)
+            throw new java.lang.IllegalArgumentException("Input Mat can't be null");
+
+        List<Mat> mats = new ArrayList<Mat>(m.rows());
+        Mat_to_vector_Mat(m, mats);
+        List<DMatch> ldm = new ArrayList<DMatch>();
+        for (Mat mi : mats) {
+            Mat_to_vector_DMatch(mi, ldm);
+            lldm.add(ldm);
+        }
+    }
+
+    // vector_vector_char
+    public static Mat vector_vector_char_to_Mat(List<List<Byte>> llb, List<Mat> mats) {
+        Mat res;
+        int lCount = (llb != null) ? llb.size() : 0;
+        if (lCount > 0) {
+            for (List<Byte> lb : llb)
+                mats.add(vector_char_to_Mat(lb));
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) {
+        if (llb == null)
+            throw new java.lang.IllegalArgumentException("Output List can't be null");
+
+        if (m == null)
+            throw new java.lang.IllegalArgumentException("Input Mat can't be null");
+
+        List<Mat> mats = new ArrayList<Mat>(m.rows());
+        Mat_to_vector_Mat(m, mats);
+        List<Byte> lb = new ArrayList<Byte>();
+        for (Mat mi : mats) {
+            Mat_to_vector_char(mi, lb);
+            llb.add(lb);
+        }
+    }
+
+}
diff --git a/modules/ml/doc/boosting.rst b/modules/ml/doc/boosting.rst
index 430b71386e..a8d368da67 100644
--- a/modules/ml/doc/boosting.rst
+++ b/modules/ml/doc/boosting.rst
@@ -59,9 +59,9 @@ To reduce computation time for boosted models without substantially losing accur
 **all**
 training examples are recomputed at each training iteration. Examples deleted at a particular iteration may be used again for learning some of the weak classifiers further [FHT98]_.
 
-.. [HTF01] Hastie, T., Tibshirani, R., Friedman, J. H. *The Elements of Statistical Learning: Data Mining, Inference, and Prediction*. Springer Series in Statistics. 2001.
+.. [HTF01] Hastie, T., Tibshirani, R., Friedman, J. H. *The Elements of Statistical Learning: Data Mining, Inference, and Prediction. Springer Series in Statistics*. 2001.
 
-.. [FHT98] Friedman, J. H., Hastie, T. and Tibshirani, R. *Additive Logistic Regression: a Statistical View of Boosting*. Technical Report, Dept. of Statistics, Stanford University, 1998.
+.. [FHT98] Friedman, J. H., Hastie, T. and Tibshirani, R. Additive Logistic Regression: a Statistical View of Boosting. Technical Report, Dept. of Statistics*, Stanford University, 1998.
 
 CvBoostParams
 -------------
diff --git a/modules/ml/doc/ertrees.rst b/modules/ml/doc/ertrees.rst
new file mode 100644
index 0000000000..29f581c39f
--- /dev/null
+++ b/modules/ml/doc/ertrees.rst
@@ -0,0 +1,15 @@
+Extremely randomized trees
+==========================
+
+Extremely randomized trees have been introduced by Pierre Geurts, Damien Ernst and Louis Wehenkel in the article "Extremely randomized trees", 2006 [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.65.7485&rep=rep1&type=pdf]. The algorithm of growing Extremely randomized trees is similar to :ref:`Random Trees` (Random Forest), but there are two differences:
+
+#. Extremely randomized trees don't apply the bagging procedure to constract the training samples for each tree. The same input training set is used to train all trees.
+
+#. Extremely randomized trees pick a node split very extremely (both a variable index and variable spliting value are chosen randomly), whereas Random Forest finds the best split (optimal one by variable index and variable spliting value) among random subset of variables.
+
+
+CvERTrees
+----------
+.. ocv:class:: CvERTrees
+
+    The class implements the Extremely randomized trees algorithm. ``CvERTrees`` is inherited from :ocv:class:`CvRTrees` and has the same interface, so see description of :ocv:class:`CvRTrees` class to get detailes. To set the training parameters of Extremely randomized trees the same class :ocv:class:`CvRTParams` is used.
diff --git a/modules/ml/doc/gradient_boosted_trees.rst b/modules/ml/doc/gradient_boosted_trees.rst
index d5d4d1a0dd..e16a52653c 100644
--- a/modules/ml/doc/gradient_boosted_trees.rst
+++ b/modules/ml/doc/gradient_boosted_trees.rst
@@ -85,7 +85,7 @@ As a result, you get the following model:
 
 .. math:: f(x) = f_0 + \nu\cdot\sum^M_{i=1}T_i(x) ,
 
-where :math:`f_0` is an initial guess (the best constant model) and :math:`\nu`
+where :math:`f_0` is the initial guess (the best constant model) and :math:`\nu`
 is a regularization parameter from the interval :math:`(0,1]`, futher called
 *shrinkage*.
 
diff --git a/modules/ml/doc/ml.rst b/modules/ml/doc/ml.rst
index cdf9a0972b..b83e7dedc3 100644
--- a/modules/ml/doc/ml.rst
+++ b/modules/ml/doc/ml.rst
@@ -17,6 +17,7 @@ Most of the classification and regression algorithms are implemented as C++ clas
     boosting
     gradient_boosted_trees
     random_trees
+    ertrees
     expectation_maximization
     neural_networks
     mldata
diff --git a/modules/ml/include/opencv2/ml/ml.hpp b/modules/ml/include/opencv2/ml/ml.hpp
index eacac664d8..68416846a7 100644
--- a/modules/ml/include/opencv2/ml/ml.hpp
+++ b/modules/ml/include/opencv2/ml/ml.hpp
@@ -552,19 +552,11 @@ protected:
 
 struct CV_EXPORTS_W_MAP CvEMParams
 {
-    CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/),
-        start_step(0/*CvEM::START_AUTO_STEP*/), probs(0), weights(0), means(0), covs(0)
-    {
-        term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON );
-    }
-
-    CvEMParams( int _nclusters, int _cov_mat_type=1/*CvEM::COV_MAT_DIAGONAL*/,
-                int _start_step=0/*CvEM::START_AUTO_STEP*/,
-                CvTermCriteria _term_crit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON),
-                const CvMat* _probs=0, const CvMat* _weights=0, const CvMat* _means=0, const CvMat** _covs=0 ) :
-                nclusters(_nclusters), cov_mat_type(_cov_mat_type), start_step(_start_step),
-                probs(_probs), weights(_weights), means(_means), covs(_covs), term_crit(_term_crit)
-    {}
+    CvEMParams();
+    CvEMParams( int nclusters, int cov_mat_type=1/*CvEM::COV_MAT_DIAGONAL*/,
+                int start_step=0/*CvEM::START_AUTO_STEP*/,
+                CvTermCriteria term_crit=cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON),
+                const CvMat* probs=0, const CvMat* weights=0, const CvMat* means=0, const CvMat** covs=0 );
 
     CV_PROP_RW int nclusters;
     CV_PROP_RW int cov_mat_type;
@@ -744,23 +736,12 @@ struct CV_EXPORTS_W_MAP CvDTreeParams
     CV_PROP_RW float regression_accuracy;
     const float* priors;
 
-    CvDTreeParams() : max_categories(10), max_depth(INT_MAX), min_sample_count(10),
-        cv_folds(10), use_surrogates(true), use_1se_rule(true),
-        truncate_pruned_tree(true), regression_accuracy(0.01f), priors(0)
-    {}
-
-    CvDTreeParams( int _max_depth, int _min_sample_count,
-                   float _regression_accuracy, bool _use_surrogates,
-                   int _max_categories, int _cv_folds,
-                   bool _use_1se_rule, bool _truncate_pruned_tree,
-                   const float* _priors ) :
-        max_categories(_max_categories), max_depth(_max_depth),
-        min_sample_count(_min_sample_count), cv_folds (_cv_folds),
-        use_surrogates(_use_surrogates), use_1se_rule(_use_1se_rule),
-        truncate_pruned_tree(_truncate_pruned_tree),
-        regression_accuracy(_regression_accuracy),
-        priors(_priors)
-    {}
+    CvDTreeParams();
+    CvDTreeParams( int max_depth, int min_sample_count,
+                   float regression_accuracy, bool use_surrogates,
+                   int max_categories, int cv_folds,
+                   bool use_1se_rule, bool truncate_pruned_tree,
+                   const float* priors );
 };
 
 
@@ -1016,26 +997,12 @@ struct CV_EXPORTS_W_MAP CvRTParams : public CvDTreeParams
     CV_PROP_RW int nactive_vars;
     CV_PROP_RW CvTermCriteria term_crit;
 
-    CvRTParams() : CvDTreeParams( 5, 10, 0, false, 10, 0, false, false, 0 ),
-        calc_var_importance(false), nactive_vars(0)
-    {
-        term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 50, 0.1 );
-    }
-
-    CvRTParams( int _max_depth, int _min_sample_count,
-                float _regression_accuracy, bool _use_surrogates,
-                int _max_categories, const float* _priors, bool _calc_var_importance,
-                int _nactive_vars, int max_num_of_trees_in_the_forest,
-                float forest_accuracy, int termcrit_type ) :
-        CvDTreeParams( _max_depth, _min_sample_count, _regression_accuracy,
-                       _use_surrogates, _max_categories, 0,
-                       false, false, _priors ),
-        calc_var_importance(_calc_var_importance),
-        nactive_vars(_nactive_vars)
-    {
-        term_crit = cvTermCriteria(termcrit_type,
-            max_num_of_trees_in_the_forest, forest_accuracy);
-    }
+    CvRTParams();
+    CvRTParams( int max_depth, int min_sample_count,
+                float regression_accuracy, bool use_surrogates,
+                int max_categories, const float* priors, bool calc_var_importance,
+                int nactive_vars, int max_num_of_trees_in_the_forest,
+                float forest_accuracy, int termcrit_type );
 };
 
 
diff --git a/modules/ml/src/boost.cpp b/modules/ml/src/boost.cpp
index e91b4f1165..b29feab394 100644
--- a/modules/ml/src/boost.cpp
+++ b/modules/ml/src/boost.cpp
@@ -1439,7 +1439,7 @@ CvBoost::trim_weights()
     for( i = 0; i < count; i++ )
     {
         double w = weak_eval->data.db[i];
-        if( sum > w )
+        if( sum <= 0 )
             break;
         sum -= w;
     }
diff --git a/modules/ml/src/em.cpp b/modules/ml/src/em.cpp
index ac2a960014..1020708eb9 100644
--- a/modules/ml/src/em.cpp
+++ b/modules/ml/src/em.cpp
@@ -68,6 +68,18 @@
    Symbol ' means transposition.
  */
 
+CvEMParams::CvEMParams() : nclusters(10), cov_mat_type(1/*CvEM::COV_MAT_DIAGONAL*/),
+    start_step(0/*CvEM::START_AUTO_STEP*/), probs(0), weights(0), means(0), covs(0)
+{
+    term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, FLT_EPSILON );
+}
+
+CvEMParams::CvEMParams( int _nclusters, int _cov_mat_type, int _start_step,
+                        CvTermCriteria _term_crit, const CvMat* _probs,
+                        const CvMat* _weights, const CvMat* _means, const CvMat** _covs ) :
+                        nclusters(_nclusters), cov_mat_type(_cov_mat_type), start_step(_start_step),
+                        probs(_probs), weights(_weights), means(_means), covs(_covs), term_crit(_term_crit)
+{}
 
 CvEM::CvEM()
 {
diff --git a/modules/ml/src/ertrees.cpp b/modules/ml/src/ertrees.cpp
index 037f39c2a0..0ddd51ad83 100644
--- a/modules/ml/src/ertrees.cpp
+++ b/modules/ml/src/ertrees.cpp
@@ -954,7 +954,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
                 int r = responses[si];
                 float val = values[si];
                 int m = missing[si];
-                double p = priors[si];
+                double p = priors[r];
                 if (m) continue;
                 if ( val < split_val )
                 {
diff --git a/modules/ml/src/knearest.cpp b/modules/ml/src/knearest.cpp
index 1d7055c140..e073d1ecc1 100644
--- a/modules/ml/src/knearest.cpp
+++ b/modules/ml/src/knearest.cpp
@@ -141,6 +141,9 @@ bool CvKNearest::train( const CvMat* _train_data, const CvMat* _responses,
     ok = true;
 
     __END__;
+    
+    if( responses && responses->data.ptr != _responses->data.ptr )
+        cvReleaseMat(&responses);
 
     return ok;
 }
diff --git a/modules/ml/src/rtrees.cpp b/modules/ml/src/rtrees.cpp
index 79ae66566f..a1a13b0189 100644
--- a/modules/ml/src/rtrees.cpp
+++ b/modules/ml/src/rtrees.cpp
@@ -190,6 +190,26 @@ void CvForestTree::read( CvFileStorage* _fs, CvFileNode* _node,
 //////////////////////////////////////////////////////////////////////////////////////////
 //                                  Random trees                                        //
 //////////////////////////////////////////////////////////////////////////////////////////
+CvRTParams::CvRTParams() : CvDTreeParams( 5, 10, 0, false, 10, 0, false, false, 0 ),
+    calc_var_importance(false), nactive_vars(0)
+{
+    term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 50, 0.1 );
+}
+
+CvRTParams::CvRTParams( int _max_depth, int _min_sample_count,
+                        float _regression_accuracy, bool _use_surrogates,
+                        int _max_categories, const float* _priors, bool _calc_var_importance,
+                        int _nactive_vars, int max_num_of_trees_in_the_forest,
+                        float forest_accuracy, int termcrit_type ) :
+    CvDTreeParams( _max_depth, _min_sample_count, _regression_accuracy,
+                   _use_surrogates, _max_categories, 0,
+                   false, false, _priors ),
+    calc_var_importance(_calc_var_importance),
+    nactive_vars(_nactive_vars)
+{
+    term_crit = cvTermCriteria(termcrit_type,
+        max_num_of_trees_in_the_forest, forest_accuracy);
+}
 
 CvRTrees::CvRTrees()
 {
diff --git a/modules/ml/src/tree.cpp b/modules/ml/src/tree.cpp
index 2df7ed3903..371c717ab6 100644
--- a/modules/ml/src/tree.cpp
+++ b/modules/ml/src/tree.cpp
@@ -1466,6 +1466,23 @@ void CvDTreeTrainData::read_params( CvFileStorage* fs, CvFileNode* node )
 }
 
 /////////////////////// Decision Tree /////////////////////////
+CvDTreeParams::CvDTreeParams() : max_categories(10), max_depth(INT_MAX), min_sample_count(10),
+    cv_folds(10), use_surrogates(true), use_1se_rule(true),
+    truncate_pruned_tree(true), regression_accuracy(0.01f), priors(0)
+{}
+
+CvDTreeParams::CvDTreeParams( int _max_depth, int _min_sample_count,
+                              float _regression_accuracy, bool _use_surrogates,
+                              int _max_categories, int _cv_folds,
+                              bool _use_1se_rule, bool _truncate_pruned_tree,
+                              const float* _priors ) :
+    max_categories(_max_categories), max_depth(_max_depth),
+    min_sample_count(_min_sample_count), cv_folds (_cv_folds),
+    use_surrogates(_use_surrogates), use_1se_rule(_use_1se_rule),
+    truncate_pruned_tree(_truncate_pruned_tree),
+    regression_accuracy(_regression_accuracy),
+    priors(_priors)
+{}
 
 CvDTree::CvDTree()
 {
diff --git a/modules/objdetect/doc/cascade_classification.rst b/modules/objdetect/doc/cascade_classification.rst
index 9db8e89156..a5d9619750 100644
--- a/modules/objdetect/doc/cascade_classification.rst
+++ b/modules/objdetect/doc/cascade_classification.rst
@@ -188,7 +188,7 @@ CascadeClassifier::detectMultiScale
 ---------------------------------------
 Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles.
 
-.. ocv:function:: void CascadeClassifier::detectMultiScale( const Mat& image,                            vector<Rect>& objects,                            double scaleFactor=1.1,                            int minNeighbors=3, int flags=0,                            Size minSize=Size())
+.. ocv:function:: void CascadeClassifier::detectMultiScale( const Mat& image, vector<Rect>& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size(), Size maxSize=Size())
 
 .. ocv:pyfunction:: cv2.CascadeClassifier.detectMultiScale(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects
 .. ocv:pyfunction:: cv2.CascadeClassifier.detectMultiScale(image, rejectLevels, levelWeights[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize[, outputRejectLevels]]]]]]) -> objects
@@ -211,6 +211,8 @@ Detects objects of different sizes in the input image. The detected objects are
 
     :param minSize: Minimum possible object size. Objects smaller than that are ignored.
 
+    :param maxSize: Maximum possible object size. Objects larger than that are ignored.
+
 
 
 CascadeClassifier::setImage
diff --git a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
index 497302d706..aa6ed24531 100644
--- a/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
+++ b/modules/objdetect/include/opencv2/objdetect/objdetect.hpp
@@ -160,9 +160,9 @@ CVAPI(int) cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade,
 // (x, y) - coordinate in level l
 typedef struct
 {
-    unsigned int x;
-    unsigned int y;
-    unsigned int l;
+    int x;
+    int y;
+    int l;
 } CvLSVMFilterPosition;
 
 // DataType: STRUCT filterObject
@@ -179,16 +179,12 @@ typedef struct
 //                   used formula H[(j * sizeX + i) * p + k], where
 //                   k - component of feature vector in cell (i, j)
 // END OF FILTER DESCRIPTION
-// xp              - auxillary parameter for internal use
-//                   size of row in feature vectors 
-//                   (yp = (int) (p / xp); p = xp * yp)
 typedef struct{
     CvLSVMFilterPosition V;
     float fineFunction[4];
-    unsigned int sizeX;
-    unsigned int sizeY;
-    unsigned int p;
-    unsigned int xp;
+    int sizeX;
+    int sizeY;
+    int numFeatures;
     float *H;
 } CvLSVMFilterObject;
 
@@ -290,8 +286,8 @@ namespace cv
 	
 ///////////////////////////// Object Detection ////////////////////////////
 
-CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, int groupThreshold, double eps=0.2);
-CV_EXPORTS_W void groupRectangles(vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(CV_IN_OUT vector<Rect>& rectList, int groupThreshold, double eps=0.2);
+CV_EXPORTS_W void groupRectangles(CV_IN_OUT vector<Rect>& rectList, CV_OUT vector<int>& weights, int groupThreshold, double eps=0.2);
 CV_EXPORTS void groupRectangles(vector<Rect>& rectList, vector<int>& rejectLevels, 
                                 vector<double>& levelWeights, int groupThreshold, double eps=0.2);
 CV_EXPORTS void groupRectangles_meanshift(vector<Rect>& rectList, vector<double>& foundWeights, vector<double>& foundScales, 
@@ -318,7 +314,15 @@ public:
 };
 
 template<> CV_EXPORTS void Ptr<CvHaarClassifierCascade>::delete_obj();
-   
+
+enum
+{
+	CASCADE_DO_CANNY_PRUNING=1,
+	CASCADE_SCALE_IMAGE=2,
+	CASCADE_FIND_BIGGEST_OBJECT=4,
+	CASCADE_DO_ROUGH_SEARCH=8
+};
+
 class CV_EXPORTS_W CascadeClassifier
 {
 public:
@@ -507,8 +511,8 @@ public:
     CV_WRAP virtual void computeGradient(const Mat& img, CV_OUT Mat& grad, CV_OUT Mat& angleOfs,
                                  Size paddingTL=Size(), Size paddingBR=Size()) const;
     
-    static vector<float> getDefaultPeopleDetector();
-	static vector<float> getDaimlerPeopleDetector();
+    CV_WRAP static vector<float> getDefaultPeopleDetector();
+	CV_WRAP static vector<float> getDaimlerPeopleDetector();
     
     CV_PROP Size winSize;
     CV_PROP Size blockSize;
diff --git a/modules/objdetect/src/_latentsvm.h b/modules/objdetect/src/_latentsvm.h
index e9be3d418c..bd44a7a261 100644
--- a/modules/objdetect/src/_latentsvm.h
+++ b/modules/objdetect/src/_latentsvm.h
@@ -37,10 +37,7 @@
 // RESULT
 // Error status
 */
-int getFeaturePyramid(IplImage * image, 
-                      const int lambda, const int k, 
-                      const int startX, const int startY, 
-                      const int W, const int H, CvLSVMFeaturePyramid **maps);
+int getFeaturePyramid(IplImage * image, CvLSVMFeaturePyramid **maps);
 
 /*
 // Getting feature map for the selected subimage  
@@ -55,7 +52,7 @@ int getFeaturePyramid(IplImage * image,
 // RESULT
 // Error status
 */
-int getFeatureMaps_dp(const IplImage * image, const int k, CvLSVMFeatureMap **map);
+int getFeatureMaps(const IplImage * image, const int k, CvLSVMFeatureMap **map);
 
 
 /*
@@ -71,7 +68,7 @@ int getFeatureMaps_dp(const IplImage * image, const int k, CvLSVMFeatureMap **ma
 // RESULT
 // Error status
 */
-int normalizationAndTruncationFeatureMaps(CvLSVMFeatureMap *map, const float alfa);
+int normalizeAndTruncate(CvLSVMFeatureMap *map, const float alfa);
 
 /*
 // Feature map reduction
diff --git a/modules/objdetect/src/_lsvm_error.h b/modules/objdetect/src/_lsvm_error.h
index a3a10b2b68..76b6be7db4 100644
--- a/modules/objdetect/src/_lsvm_error.h
+++ b/modules/objdetect/src/_lsvm_error.h
@@ -2,6 +2,7 @@
 #define LSVM_ERROR
 
 #define LATENT_SVM_OK 0
+#define LATENT_SVM_MEM_NULL 2
 #define DISTANCE_TRANSFORM_OK 1
 #define DISTANCE_TRANSFORM_GET_INTERSECTION_ERROR -1
 #define DISTANCE_TRANSFORM_ERROR -2
diff --git a/modules/objdetect/src/_lsvm_routine.h b/modules/objdetect/src/_lsvm_routine.h
index 2249d3c769..4efa11086b 100644
--- a/modules/objdetect/src/_lsvm_routine.h
+++ b/modules/objdetect/src/_lsvm_routine.h
@@ -13,18 +13,18 @@
 // Error status is return value
 //////////////////////////////////////////////////////////////
 int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX, const int sizeY, 
-                      const int p, const int xp);
+                      const int p);
 int freeFilterObject (CvLSVMFilterObject **obj);
 
 int allocFeatureMapObject(CvLSVMFeatureMap **obj, const int sizeX, const int sizeY,
-                          const int p, const int xp);
+                          const int p);
 int freeFeatureMapObject (CvLSVMFeatureMap **obj);
 
 #ifdef __cplusplus
 extern "C"
 #endif
 int allocFeaturePyramidObject(CvLSVMFeaturePyramid **obj, 
-                              const int lambda, const int countLevel);
+                              const int countLevel);
 
 #ifdef __cplusplus
 extern "C"
diff --git a/modules/objdetect/src/_lsvm_types.h b/modules/objdetect/src/_lsvm_types.h
index 2f868071db..347766930e 100644
--- a/modules/objdetect/src/_lsvm_types.h
+++ b/modules/objdetect/src/_lsvm_types.h
@@ -14,7 +14,7 @@
 
 // The number of elements in bin
 // The number of sectors in gradient histogram building
-#define CNTPARTION 9
+#define NUM_SECTOR 9
 
 // The number of levels in image resize procedure
 // We need Lambda levels to resize image twice
@@ -23,6 +23,8 @@
 // Block size. Used in feature pyramid building procedure
 #define SIDE_LENGTH 8
 
+#define VAL_OF_TRUNCATE 0.2f 
+
 //////////////////////////////////////////////////////////////
 // main data structures                                     //
 //////////////////////////////////////////////////////////////
@@ -30,31 +32,24 @@
 // DataType: STRUCT featureMap
 // FEATURE MAP DESCRIPTION
 //   Rectangular map (sizeX x sizeY), 
-//   every cell stores feature vector (dimension = p)
-// H               - matrix of feature vectors
+//   every cell stores feature vector (dimension = numFeatures)
+// map             - matrix of feature vectors
 //                   to set and get feature vectors (i,j) 
-//                   used formula Map[(j * sizeX + i) * p + k], where
+//                   used formula map[(j * sizeX + i) * p + k], where
 //                   k - component of feature vector in cell (i, j)
-// END OF FEATURE MAP DESCRIPTION
-// xp              - auxillary parameter for internal use
-//                   size of row in feature vectors 
-//                   (yp = (int) (p / xp); p = xp * yp)
 typedef struct{
     int sizeX;
     int sizeY;
-    int p;
-    int xp;
-    float *Map;
+    int numFeatures;
+    float *map;
 } CvLSVMFeatureMap;
 
 // DataType: STRUCT featurePyramid
 //
-// countLevel   - number of levels in the feature pyramid
-// lambda       - resize scale coefficient
+// numLevels    - number of levels in the feature pyramid
 // pyramid      - array of pointers to feature map at different levels
 typedef struct{
-    int countLevel;
-    int lambda;
+    int numLevels;
     CvLSVMFeatureMap **pyramid;
 } CvLSVMFeaturePyramid;
 
@@ -74,14 +69,14 @@ typedef struct{
 // DataType: STRUCT fftImage
 // The structure stores FFT image
 //
-// p            - number of channels
+// numFeatures  - number of channels
 // x            - array of FFT images for 2d signals
 // n            - number of rows
 // m            - number of collums
 typedef struct{
-    unsigned int p;
-    unsigned int dimX;
-    unsigned int dimY;
+    int numFeatures;
+    int dimX;
+    int dimY;
     float **channels;
 } CvLSVMFftImage;
 
diff --git a/modules/objdetect/src/cascadedetect.cpp b/modules/objdetect/src/cascadedetect.cpp
index 1db2ab7297..d67ad23992 100644
--- a/modules/objdetect/src/cascadedetect.cpp
+++ b/modules/objdetect/src/cascadedetect.cpp
@@ -42,6 +42,8 @@
 #include "precomp.hpp"
 #include <cstdio>
 
+#include "cascadedetect.hpp"
+
 namespace cv
 {
     
@@ -173,7 +175,7 @@ public:
 	    densityKernel = densKer;
         weightsV = wV;
         positionsV = posV;
-        positionsCount = posV.size();
+        positionsCount = (int)posV.size();
 	    meanshiftV.resize(positionsCount);
         distanceV.resize(positionsCount);
         modeEps = modeEps;
@@ -316,7 +318,7 @@ protected:
 static void groupRectangles_meanshift(vector<Rect>& rectList, double detectThreshold, vector<double>* foundWeights, 
 									  vector<double>& scales, Size winDetSize)
 {
-    int detectionCount = rectList.size();
+    int detectionCount = (int)rectList.size();
     vector<Point3d> hits(detectionCount), resultHits;
     vector<double> hitWeights(detectionCount), resultWeights;
     Point2d hitCenter;
@@ -379,60 +381,6 @@ void groupRectangles_meanshift(vector<Rect>& rectList, vector<double>& foundWeig
 }
 
     
-#define CC_CASCADE_PARAMS "cascadeParams"
-#define CC_STAGE_TYPE     "stageType"
-#define CC_FEATURE_TYPE   "featureType"
-#define CC_HEIGHT         "height"
-#define CC_WIDTH          "width"
-
-#define CC_STAGE_NUM    "stageNum"
-#define CC_STAGES       "stages"
-#define CC_STAGE_PARAMS "stageParams"
-
-#define CC_BOOST            "BOOST"
-#define CC_MAX_DEPTH        "maxDepth"
-#define CC_WEAK_COUNT       "maxWeakCount"
-#define CC_STAGE_THRESHOLD  "stageThreshold"
-#define CC_WEAK_CLASSIFIERS "weakClassifiers"
-#define CC_INTERNAL_NODES   "internalNodes"
-#define CC_LEAF_VALUES      "leafValues"
-
-#define CC_FEATURES       "features"
-#define CC_FEATURE_PARAMS "featureParams"
-#define CC_MAX_CAT_COUNT  "maxCatCount"
-
-#define CC_HAAR   "HAAR"
-#define CC_RECTS  "rects"
-#define CC_TILTED "tilted"
-
-#define CC_LBP  "LBP"
-#define CC_RECT "rect"
-
-#define CV_SUM_PTRS( p0, p1, p2, p3, sum, rect, step )                    \
-    /* (x, y) */                                                          \
-    (p0) = sum + (rect).x + (step) * (rect).y,                            \
-    /* (x + w, y) */                                                      \
-    (p1) = sum + (rect).x + (rect).width + (step) * (rect).y,             \
-    /* (x + w, y) */                                                      \
-    (p2) = sum + (rect).x + (step) * ((rect).y + (rect).height),          \
-    /* (x + w, y + h) */                                                  \
-    (p3) = sum + (rect).x + (rect).width + (step) * ((rect).y + (rect).height)
-
-#define CV_TILTED_PTRS( p0, p1, p2, p3, tilted, rect, step )                        \
-    /* (x, y) */                                                                    \
-    (p0) = tilted + (rect).x + (step) * (rect).y,                                   \
-    /* (x - h, y + h) */                                                            \
-    (p1) = tilted + (rect).x - (rect).height + (step) * ((rect).y + (rect).height), \
-    /* (x + w, y + w) */                                                            \
-    (p2) = tilted + (rect).x + (rect).width + (step) * ((rect).y + (rect).width),   \
-    /* (x + w - h, y + w + h) */                                                    \
-    (p3) = tilted + (rect).x + (rect).width - (rect).height                         \
-           + (step) * ((rect).y + (rect).width + (rect).height)
-
-#define CALC_SUM_(p0, p1, p2, p3, offset) \
-    ((p0)[offset] - (p1)[offset] - (p2)[offset] + (p3)[offset])   
-    
-#define CALC_SUM(rect,offset) CALC_SUM_((rect)[0], (rect)[1], (rect)[2], (rect)[3], offset)
 
 FeatureEvaluator::~FeatureEvaluator() {}
 bool FeatureEvaluator::read(const FileNode&) {return true;}
@@ -444,101 +392,6 @@ double FeatureEvaluator::calcOrd(int) const { return 0.; }
 int FeatureEvaluator::calcCat(int) const { return 0; }
 
 //----------------------------------------------  HaarEvaluator ---------------------------------------
-class HaarEvaluator : public FeatureEvaluator
-{
-public:
-    struct Feature
-    {
-        Feature();
-        
-        float calc( int offset ) const;
-        void updatePtrs( const Mat& sum );
-        bool read( const FileNode& node );
-        
-        bool tilted;
-        
-        enum { RECT_NUM = 3 };
-        
-        struct
-        {
-            Rect r;
-            float weight;
-        } rect[RECT_NUM];
-        
-        const int* p[RECT_NUM][4];
-    };
-    
-    HaarEvaluator();
-    virtual ~HaarEvaluator();
-
-    virtual bool read( const FileNode& node );
-    virtual Ptr<FeatureEvaluator> clone() const;
-    virtual int getFeatureType() const { return FeatureEvaluator::HAAR; }
-
-    virtual bool setImage(const Mat&, Size origWinSize);
-    virtual bool setWindow(Point pt);
-
-    double operator()(int featureIdx) const
-    { return featuresPtr[featureIdx].calc(offset) * varianceNormFactor; }
-    virtual double calcOrd(int featureIdx) const
-    { return (*this)(featureIdx); }
-
-private:
-    Size origWinSize;
-    Ptr<vector<Feature> > features;
-    Feature* featuresPtr; // optimization
-    bool hasTiltedFeatures;
-
-    Mat sum0, sqsum0, tilted0;
-    Mat sum, sqsum, tilted;
-    
-    Rect normrect;
-    const int *p[4];
-    const double *pq[4];
-    
-    int offset;
-    double varianceNormFactor;    
-};
-
-inline HaarEvaluator::Feature :: Feature()
-{
-    tilted = false;
-    rect[0].r = rect[1].r = rect[2].r = Rect();
-    rect[0].weight = rect[1].weight = rect[2].weight = 0;
-    p[0][0] = p[0][1] = p[0][2] = p[0][3] = 
-        p[1][0] = p[1][1] = p[1][2] = p[1][3] = 
-        p[2][0] = p[2][1] = p[2][2] = p[2][3] = 0;
-}
-
-inline float HaarEvaluator::Feature :: calc( int offset ) const
-{
-    float ret = rect[0].weight * CALC_SUM(p[0], offset) + rect[1].weight * CALC_SUM(p[1], offset);
-
-    if( rect[2].weight != 0.0f )
-        ret += rect[2].weight * CALC_SUM(p[2], offset);
-    
-    return ret;
-}
-
-inline void HaarEvaluator::Feature :: updatePtrs( const Mat& sum )
-{
-    const int* ptr = (const int*)sum.data;
-    size_t step = sum.step/sizeof(ptr[0]);
-    if (tilted)
-    {
-        CV_TILTED_PTRS( p[0][0], p[0][1], p[0][2], p[0][3], ptr, rect[0].r, step );
-        CV_TILTED_PTRS( p[1][0], p[1][1], p[1][2], p[1][3], ptr, rect[1].r, step );
-        if (rect[2].weight)
-            CV_TILTED_PTRS( p[2][0], p[2][1], p[2][2], p[2][3], ptr, rect[2].r, step );
-    }
-    else
-    {
-        CV_SUM_PTRS( p[0][0], p[0][1], p[0][2], p[0][3], ptr, rect[0].r, step );
-        CV_SUM_PTRS( p[1][0], p[1][1], p[1][2], p[1][3], ptr, rect[1].r, step );
-        if (rect[2].weight)
-            CV_SUM_PTRS( p[2][0], p[2][1], p[2][2], p[2][3], ptr, rect[2].r, step );
-    }
-}
 
 bool HaarEvaluator::Feature :: read( const FileNode& node )
 {
@@ -670,84 +523,6 @@ bool  HaarEvaluator::setWindow( Point pt )
 }
 
 //----------------------------------------------  LBPEvaluator -------------------------------------
-
-class LBPEvaluator : public FeatureEvaluator
-{
-public:
-    struct Feature
-    {
-        Feature();
-        Feature( int x, int y, int _block_w, int _block_h  ) : 
-        rect(x, y, _block_w, _block_h) {}
-        
-        int calc( int offset ) const;
-        void updatePtrs( const Mat& sum );
-        bool read(const FileNode& node );
-        
-        Rect rect; // weight and height for block
-        const int* p[16]; // fast
-    };
-    
-    LBPEvaluator();
-    virtual ~LBPEvaluator();
-    
-    virtual bool read( const FileNode& node );
-    virtual Ptr<FeatureEvaluator> clone() const;
-    virtual int getFeatureType() const { return FeatureEvaluator::LBP; }
-
-    virtual bool setImage(const Mat& image, Size _origWinSize);
-    virtual bool setWindow(Point pt);
-    
-    int operator()(int featureIdx) const
-    { return featuresPtr[featureIdx].calc(offset); }
-    virtual int calcCat(int featureIdx) const
-    { return (*this)(featureIdx); }
-private:
-    Size origWinSize;
-    Ptr<vector<Feature> > features;
-    Feature* featuresPtr; // optimization
-    Mat sum0, sum;
-    Rect normrect;
-
-    int offset;
-};    
-    
-    
-inline LBPEvaluator::Feature :: Feature()
-{
-    rect = Rect();
-    for( int i = 0; i < 16; i++ )
-        p[i] = 0;
-}
-
-inline int LBPEvaluator::Feature :: calc( int offset ) const
-{
-    int cval = CALC_SUM_( p[5], p[6], p[9], p[10], offset );
-    
-    return (CALC_SUM_( p[0], p[1], p[4], p[5], offset ) >= cval ? 128 : 0) |   // 0
-           (CALC_SUM_( p[1], p[2], p[5], p[6], offset ) >= cval ? 64 : 0) |    // 1
-           (CALC_SUM_( p[2], p[3], p[6], p[7], offset ) >= cval ? 32 : 0) |    // 2
-           (CALC_SUM_( p[6], p[7], p[10], p[11], offset ) >= cval ? 16 : 0) |  // 5
-           (CALC_SUM_( p[10], p[11], p[14], p[15], offset ) >= cval ? 8 : 0)|  // 8
-           (CALC_SUM_( p[9], p[10], p[13], p[14], offset ) >= cval ? 4 : 0)|   // 7
-           (CALC_SUM_( p[8], p[9], p[12], p[13], offset ) >= cval ? 2 : 0)|    // 6
-           (CALC_SUM_( p[4], p[5], p[8], p[9], offset ) >= cval ? 1 : 0);
-}
-
-inline void LBPEvaluator::Feature :: updatePtrs( const Mat& sum )
-{
-    const int* ptr = (const int*)sum.data;
-    size_t step = sum.step/sizeof(ptr[0]);
-    Rect tr = rect;
-    CV_SUM_PTRS( p[0], p[1], p[4], p[5], ptr, tr, step );
-    tr.x += 2*rect.width;
-    CV_SUM_PTRS( p[2], p[3], p[6], p[7], ptr, tr, step );
-    tr.y += 2*rect.height;
-    CV_SUM_PTRS( p[10], p[11], p[14], p[15], ptr, tr, step );
-    tr.x -= 2*rect.width;
-    CV_SUM_PTRS( p[8], p[9], p[12], p[13], ptr, tr, step );
-}
-
 bool LBPEvaluator::Feature :: read(const FileNode& node )
 {
     FileNode rnode = node[CC_RECT];
@@ -862,171 +637,6 @@ bool CascadeClassifier::load(const string& filename)
     return !oldCascade.empty();
 }
     
-template<class FEval>
-inline int predictOrdered( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
-{
-    int nstages = (int)cascade.data.stages.size();
-    int nodeOfs = 0, leafOfs = 0;
-    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
-    float* cascadeLeaves = &cascade.data.leaves[0];
-    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
-    CascadeClassifier::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
-    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
-    
-    for( int si = 0; si < nstages; si++ )
-    {
-        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
-        int wi, ntrees = stage.ntrees;
-        sum = 0;
-        
-        for( wi = 0; wi < ntrees; wi++ )
-        {
-            CascadeClassifier::Data::DTree& weak = cascadeWeaks[stage.first + wi];
-            int idx = 0, root = nodeOfs;
-
-            do
-            {
-                CascadeClassifier::Data::DTreeNode& node = cascadeNodes[root + idx];
-                double val = featureEvaluator(node.featureIdx);
-                idx = val < node.threshold ? node.left : node.right;
-            }
-            while( idx > 0 );
-            sum += cascadeLeaves[leafOfs - idx];
-            nodeOfs += weak.nodeCount;
-            leafOfs += weak.nodeCount + 1;
-        }
-        if( sum < stage.threshold )
-            return -si;            
-    }
-    return 1;
-}
-
-template<class FEval>
-inline int predictCategorical( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
-{
-    int nstages = (int)cascade.data.stages.size();
-    int nodeOfs = 0, leafOfs = 0;
-    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
-    size_t subsetSize = (cascade.data.ncategories + 31)/32;
-    int* cascadeSubsets = &cascade.data.subsets[0];
-    float* cascadeLeaves = &cascade.data.leaves[0];
-    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
-    CascadeClassifier::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
-    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
-    
-    for(int si = 0; si < nstages; si++ )
-    {
-        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
-        int wi, ntrees = stage.ntrees;
-        sum = 0;
-        
-        for( wi = 0; wi < ntrees; wi++ )
-        {
-            CascadeClassifier::Data::DTree& weak = cascadeWeaks[stage.first + wi];
-            int idx = 0, root = nodeOfs;
-            do
-            {
-                CascadeClassifier::Data::DTreeNode& node = cascadeNodes[root + idx];
-                int c = featureEvaluator(node.featureIdx);
-                const int* subset = &cascadeSubsets[(root + idx)*subsetSize];
-                idx = (subset[c>>5] & (1 << (c & 31))) ? node.left : node.right;
-            }
-            while( idx > 0 );
-            sum += cascadeLeaves[leafOfs - idx];
-            nodeOfs += weak.nodeCount;
-            leafOfs += weak.nodeCount + 1;
-        }
-        if( sum < stage.threshold )
-            return -si;            
-    }
-    return 1;
-}
-
-template<class FEval>
-inline int predictOrderedStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
-{
-    int nodeOfs = 0, leafOfs = 0;
-    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
-    float* cascadeLeaves = &cascade.data.leaves[0];
-    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
-    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
-
-    int nstages = (int)cascade.data.stages.size();
-    for( int stageIdx = 0; stageIdx < nstages; stageIdx++ )
-    {
-        CascadeClassifier::Data::Stage& stage = cascadeStages[stageIdx];
-        sum = 0.0;
-
-        int ntrees = stage.ntrees;
-        for( int i = 0; i < ntrees; i++, nodeOfs++, leafOfs+= 2 )
-        {
-            CascadeClassifier::Data::DTreeNode& node = cascadeNodes[nodeOfs];
-            double value = featureEvaluator(node.featureIdx);
-            sum += cascadeLeaves[ value < node.threshold ? leafOfs : leafOfs + 1 ];
-        }
-
-        if( sum < stage.threshold )
-            return -stageIdx;
-    }
-
-    return 1;
-}
-
-template<class FEval>
-inline int predictCategoricalStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
-{
-    int nstages = (int)cascade.data.stages.size();
-    int nodeOfs = 0, leafOfs = 0;
-    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
-    size_t subsetSize = (cascade.data.ncategories + 31)/32;
-    int* cascadeSubsets = &cascade.data.subsets[0];
-    float* cascadeLeaves = &cascade.data.leaves[0];
-    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
-    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
-
-#ifdef HAVE_TEGRA_OPTIMIZATION
-    float tmp; // float accumulator -- float operations are quicker 
-#endif
-    for( int si = 0; si < nstages; si++ )
-    {
-        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
-        int wi, ntrees = stage.ntrees;
-#ifdef HAVE_TEGRA_OPTIMIZATION
-	tmp = 0;
-#else
-        sum = 0;
-#endif
-
-        for( wi = 0; wi < ntrees; wi++ )
-        {
-            CascadeClassifier::Data::DTreeNode& node = cascadeNodes[nodeOfs];
-            int c = featureEvaluator(node.featureIdx);
-            const int* subset = &cascadeSubsets[nodeOfs*subsetSize];
-#ifdef HAVE_TEGRA_OPTIMIZATION
-            tmp += cascadeLeaves[ subset[c>>5] & (1 << (c & 31)) ? leafOfs : leafOfs+1];
-#else
-            sum += cascadeLeaves[ subset[c>>5] & (1 << (c & 31)) ? leafOfs : leafOfs+1];
-#endif
-            nodeOfs++;
-            leafOfs += 2;
-        }
-#ifdef HAVE_TEGRA_OPTIMIZATION
-        if( tmp < stage.threshold ) {
-	    sum = (double)tmp;
-            return -si;            
-	}
-#else
-        if( sum < stage.threshold )
-            return -si;            
-#endif
-    }
-
-#ifdef HAVE_TEGRA_OPTIMIZATION
-    sum = (double)tmp;
-#endif
-
-    return 1;
-}
 
 int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& featureEvaluator, Point pt, double& weight )
 {
@@ -1080,7 +690,7 @@ struct CascadeClassifierInvoker
                 if( rejectLevels )
                 {
                     if( result == 1 )
-                        result =  -1*classifier->data.stages.size();
+                        result =  -(int)classifier->data.stages.size();
                     if( classifier->data.stages.size() + result < 4 )
                     {
                         rectangles->push_back(Rect(cvRound(x*scalingFactor), cvRound(y*scalingFactor), winSize.width, winSize.height)); 
diff --git a/modules/objdetect/src/cascadedetect.hpp b/modules/objdetect/src/cascadedetect.hpp
new file mode 100644
index 0000000000..b0f086e987
--- /dev/null
+++ b/modules/objdetect/src/cascadedetect.hpp
@@ -0,0 +1,410 @@
+#pragma once
+
+namespace cv
+{
+
+#define CC_CASCADE_PARAMS "cascadeParams"
+#define CC_STAGE_TYPE     "stageType"
+#define CC_FEATURE_TYPE   "featureType"
+#define CC_HEIGHT         "height"
+#define CC_WIDTH          "width"
+
+#define CC_STAGE_NUM    "stageNum"
+#define CC_STAGES       "stages"
+#define CC_STAGE_PARAMS "stageParams"
+
+#define CC_BOOST            "BOOST"
+#define CC_MAX_DEPTH        "maxDepth"
+#define CC_WEAK_COUNT       "maxWeakCount"
+#define CC_STAGE_THRESHOLD  "stageThreshold"
+#define CC_WEAK_CLASSIFIERS "weakClassifiers"
+#define CC_INTERNAL_NODES   "internalNodes"
+#define CC_LEAF_VALUES      "leafValues"
+
+#define CC_FEATURES       "features"
+#define CC_FEATURE_PARAMS "featureParams"
+#define CC_MAX_CAT_COUNT  "maxCatCount"
+
+#define CC_HAAR   "HAAR"
+#define CC_RECTS  "rects"
+#define CC_TILTED "tilted"
+
+#define CC_LBP  "LBP"
+#define CC_RECT "rect"
+
+#define CV_SUM_PTRS( p0, p1, p2, p3, sum, rect, step )                    \
+    /* (x, y) */                                                          \
+    (p0) = sum + (rect).x + (step) * (rect).y,                            \
+    /* (x + w, y) */                                                      \
+    (p1) = sum + (rect).x + (rect).width + (step) * (rect).y,             \
+    /* (x + w, y) */                                                      \
+    (p2) = sum + (rect).x + (step) * ((rect).y + (rect).height),          \
+    /* (x + w, y + h) */                                                  \
+    (p3) = sum + (rect).x + (rect).width + (step) * ((rect).y + (rect).height)
+
+#define CV_TILTED_PTRS( p0, p1, p2, p3, tilted, rect, step )                        \
+    /* (x, y) */                                                                    \
+    (p0) = tilted + (rect).x + (step) * (rect).y,                                   \
+    /* (x - h, y + h) */                                                            \
+    (p1) = tilted + (rect).x - (rect).height + (step) * ((rect).y + (rect).height), \
+    /* (x + w, y + w) */                                                            \
+    (p2) = tilted + (rect).x + (rect).width + (step) * ((rect).y + (rect).width),   \
+    /* (x + w - h, y + w + h) */                                                    \
+    (p3) = tilted + (rect).x + (rect).width - (rect).height                         \
+           + (step) * ((rect).y + (rect).width + (rect).height)
+
+#define CALC_SUM_(p0, p1, p2, p3, offset) \
+    ((p0)[offset] - (p1)[offset] - (p2)[offset] + (p3)[offset])   
+    
+#define CALC_SUM(rect,offset) CALC_SUM_((rect)[0], (rect)[1], (rect)[2], (rect)[3], offset)
+
+
+//----------------------------------------------  HaarEvaluator ---------------------------------------
+class HaarEvaluator : public FeatureEvaluator
+{
+public:
+    struct Feature
+    {
+        Feature();
+        
+        float calc( int offset ) const;
+        void updatePtrs( const Mat& sum );
+        bool read( const FileNode& node );
+        
+        bool tilted;
+        
+        enum { RECT_NUM = 3 };
+        
+        struct
+        {
+            Rect r;
+            float weight;
+        } rect[RECT_NUM];
+        
+        const int* p[RECT_NUM][4];
+    };
+    
+    HaarEvaluator();
+    virtual ~HaarEvaluator();
+
+    virtual bool read( const FileNode& node );
+    virtual Ptr<FeatureEvaluator> clone() const;
+    virtual int getFeatureType() const { return FeatureEvaluator::HAAR; }
+
+    virtual bool setImage(const Mat&, Size origWinSize);
+    virtual bool setWindow(Point pt);
+
+    double operator()(int featureIdx) const
+    { return featuresPtr[featureIdx].calc(offset) * varianceNormFactor; }
+    virtual double calcOrd(int featureIdx) const
+    { return (*this)(featureIdx); }
+
+protected:
+    Size origWinSize;
+    Ptr<vector<Feature> > features;
+    Feature* featuresPtr; // optimization
+    bool hasTiltedFeatures;
+
+    Mat sum0, sqsum0, tilted0;
+    Mat sum, sqsum, tilted;
+    
+    Rect normrect;
+    const int *p[4];
+    const double *pq[4];
+    
+    int offset;
+    double varianceNormFactor;    
+};
+
+inline HaarEvaluator::Feature :: Feature()
+{
+    tilted = false;
+    rect[0].r = rect[1].r = rect[2].r = Rect();
+    rect[0].weight = rect[1].weight = rect[2].weight = 0;
+    p[0][0] = p[0][1] = p[0][2] = p[0][3] = 
+        p[1][0] = p[1][1] = p[1][2] = p[1][3] = 
+        p[2][0] = p[2][1] = p[2][2] = p[2][3] = 0;
+}
+
+inline float HaarEvaluator::Feature :: calc( int offset ) const
+{
+    float ret = rect[0].weight * CALC_SUM(p[0], offset) + rect[1].weight * CALC_SUM(p[1], offset);
+
+    if( rect[2].weight != 0.0f )
+        ret += rect[2].weight * CALC_SUM(p[2], offset);
+    
+    return ret;
+}
+
+inline void HaarEvaluator::Feature :: updatePtrs( const Mat& sum )
+{
+    const int* ptr = (const int*)sum.data;
+    size_t step = sum.step/sizeof(ptr[0]);
+    if (tilted)
+    {
+        CV_TILTED_PTRS( p[0][0], p[0][1], p[0][2], p[0][3], ptr, rect[0].r, step );
+        CV_TILTED_PTRS( p[1][0], p[1][1], p[1][2], p[1][3], ptr, rect[1].r, step );
+        if (rect[2].weight)
+            CV_TILTED_PTRS( p[2][0], p[2][1], p[2][2], p[2][3], ptr, rect[2].r, step );
+    }
+    else
+    {
+        CV_SUM_PTRS( p[0][0], p[0][1], p[0][2], p[0][3], ptr, rect[0].r, step );
+        CV_SUM_PTRS( p[1][0], p[1][1], p[1][2], p[1][3], ptr, rect[1].r, step );
+        if (rect[2].weight)
+            CV_SUM_PTRS( p[2][0], p[2][1], p[2][2], p[2][3], ptr, rect[2].r, step );
+    }
+}
+
+
+//----------------------------------------------  LBPEvaluator -------------------------------------
+
+class LBPEvaluator : public FeatureEvaluator
+{
+public:
+    struct Feature
+    {
+        Feature();
+        Feature( int x, int y, int _block_w, int _block_h  ) : 
+        rect(x, y, _block_w, _block_h) {}
+        
+        int calc( int offset ) const;
+        void updatePtrs( const Mat& sum );
+        bool read(const FileNode& node );
+        
+        Rect rect; // weight and height for block
+        const int* p[16]; // fast
+    };
+    
+    LBPEvaluator();
+    virtual ~LBPEvaluator();
+    
+    virtual bool read( const FileNode& node );
+    virtual Ptr<FeatureEvaluator> clone() const;
+    virtual int getFeatureType() const { return FeatureEvaluator::LBP; }
+
+    virtual bool setImage(const Mat& image, Size _origWinSize);
+    virtual bool setWindow(Point pt);
+    
+    int operator()(int featureIdx) const
+    { return featuresPtr[featureIdx].calc(offset); }
+    virtual int calcCat(int featureIdx) const
+    { return (*this)(featureIdx); }
+protected:
+    Size origWinSize;
+    Ptr<vector<Feature> > features;
+    Feature* featuresPtr; // optimization
+    Mat sum0, sum;
+    Rect normrect;
+
+    int offset;
+};    
+    
+    
+inline LBPEvaluator::Feature :: Feature()
+{
+    rect = Rect();
+    for( int i = 0; i < 16; i++ )
+        p[i] = 0;
+}
+
+inline int LBPEvaluator::Feature :: calc( int offset ) const
+{
+    int cval = CALC_SUM_( p[5], p[6], p[9], p[10], offset );
+    
+    return (CALC_SUM_( p[0], p[1], p[4], p[5], offset ) >= cval ? 128 : 0) |   // 0
+           (CALC_SUM_( p[1], p[2], p[5], p[6], offset ) >= cval ? 64 : 0) |    // 1
+           (CALC_SUM_( p[2], p[3], p[6], p[7], offset ) >= cval ? 32 : 0) |    // 2
+           (CALC_SUM_( p[6], p[7], p[10], p[11], offset ) >= cval ? 16 : 0) |  // 5
+           (CALC_SUM_( p[10], p[11], p[14], p[15], offset ) >= cval ? 8 : 0)|  // 8
+           (CALC_SUM_( p[9], p[10], p[13], p[14], offset ) >= cval ? 4 : 0)|   // 7
+           (CALC_SUM_( p[8], p[9], p[12], p[13], offset ) >= cval ? 2 : 0)|    // 6
+           (CALC_SUM_( p[4], p[5], p[8], p[9], offset ) >= cval ? 1 : 0);
+}
+
+inline void LBPEvaluator::Feature :: updatePtrs( const Mat& sum )
+{
+    const int* ptr = (const int*)sum.data;
+    size_t step = sum.step/sizeof(ptr[0]);
+    Rect tr = rect;
+    CV_SUM_PTRS( p[0], p[1], p[4], p[5], ptr, tr, step );
+    tr.x += 2*rect.width;
+    CV_SUM_PTRS( p[2], p[3], p[6], p[7], ptr, tr, step );
+    tr.y += 2*rect.height;
+    CV_SUM_PTRS( p[10], p[11], p[14], p[15], ptr, tr, step );
+    tr.x -= 2*rect.width;
+    CV_SUM_PTRS( p[8], p[9], p[12], p[13], ptr, tr, step );
+}
+
+
+
+
+//----------------------------------------------  predictor functions -------------------------------------
+
+template<class FEval>
+inline int predictOrdered( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    int nstages = (int)cascade.data.stages.size();
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifier::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
+    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
+    
+    for( int si = 0; si < nstages; si++ )
+    {
+        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+        sum = 0;
+        
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            CascadeClassifier::Data::DTree& weak = cascadeWeaks[stage.first + wi];
+            int idx = 0, root = nodeOfs;
+
+            do
+            {
+                CascadeClassifier::Data::DTreeNode& node = cascadeNodes[root + idx];
+                double val = featureEvaluator(node.featureIdx);
+                idx = val < node.threshold ? node.left : node.right;
+            }
+            while( idx > 0 );
+            sum += cascadeLeaves[leafOfs - idx];
+            nodeOfs += weak.nodeCount;
+            leafOfs += weak.nodeCount + 1;
+        }
+        if( sum < stage.threshold )
+            return -si;            
+    }
+    return 1;
+}
+
+template<class FEval>
+inline int predictCategorical( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    int nstages = (int)cascade.data.stages.size();
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    size_t subsetSize = (cascade.data.ncategories + 31)/32;
+    int* cascadeSubsets = &cascade.data.subsets[0];
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifier::Data::DTree* cascadeWeaks = &cascade.data.classifiers[0];
+    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
+    
+    for(int si = 0; si < nstages; si++ )
+    {
+        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+        sum = 0;
+        
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            CascadeClassifier::Data::DTree& weak = cascadeWeaks[stage.first + wi];
+            int idx = 0, root = nodeOfs;
+            do
+            {
+                CascadeClassifier::Data::DTreeNode& node = cascadeNodes[root + idx];
+                int c = featureEvaluator(node.featureIdx);
+                const int* subset = &cascadeSubsets[(root + idx)*subsetSize];
+                idx = (subset[c>>5] & (1 << (c & 31))) ? node.left : node.right;
+            }
+            while( idx > 0 );
+            sum += cascadeLeaves[leafOfs - idx];
+            nodeOfs += weak.nodeCount;
+            leafOfs += weak.nodeCount + 1;
+        }
+        if( sum < stage.threshold )
+            return -si;            
+    }
+    return 1;
+}
+
+template<class FEval>
+inline int predictOrderedStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+    int nstages = (int)cascade.data.stages.size();
+    for( int stageIdx = 0; stageIdx < nstages; stageIdx++ )
+    {
+        CascadeClassifier::Data::Stage& stage = cascadeStages[stageIdx];
+        sum = 0.0;
+
+        int ntrees = stage.ntrees;
+        for( int i = 0; i < ntrees; i++, nodeOfs++, leafOfs+= 2 )
+        {
+            CascadeClassifier::Data::DTreeNode& node = cascadeNodes[nodeOfs];
+            double value = featureEvaluator(node.featureIdx);
+            sum += cascadeLeaves[ value < node.threshold ? leafOfs : leafOfs + 1 ];
+        }
+
+        if( sum < stage.threshold )
+            return -stageIdx;
+    }
+
+    return 1;
+}
+
+template<class FEval>
+inline int predictCategoricalStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &_featureEvaluator, double& sum )
+{
+    int nstages = (int)cascade.data.stages.size();
+    int nodeOfs = 0, leafOfs = 0;
+    FEval& featureEvaluator = (FEval&)*_featureEvaluator;
+    size_t subsetSize = (cascade.data.ncategories + 31)/32;
+    int* cascadeSubsets = &cascade.data.subsets[0];
+    float* cascadeLeaves = &cascade.data.leaves[0];
+    CascadeClassifier::Data::DTreeNode* cascadeNodes = &cascade.data.nodes[0];
+    CascadeClassifier::Data::Stage* cascadeStages = &cascade.data.stages[0];
+
+#ifdef HAVE_TEGRA_OPTIMIZATION
+    float tmp; // float accumulator -- float operations are quicker 
+#endif
+    for( int si = 0; si < nstages; si++ )
+    {
+        CascadeClassifier::Data::Stage& stage = cascadeStages[si];
+        int wi, ntrees = stage.ntrees;
+#ifdef HAVE_TEGRA_OPTIMIZATION
+        tmp = 0;
+#else
+        sum = 0;
+#endif
+
+        for( wi = 0; wi < ntrees; wi++ )
+        {
+            CascadeClassifier::Data::DTreeNode& node = cascadeNodes[nodeOfs];
+            int c = featureEvaluator(node.featureIdx);
+            const int* subset = &cascadeSubsets[nodeOfs*subsetSize];
+#ifdef HAVE_TEGRA_OPTIMIZATION
+            tmp += cascadeLeaves[ subset[c>>5] & (1 << (c & 31)) ? leafOfs : leafOfs+1];
+#else
+            sum += cascadeLeaves[ subset[c>>5] & (1 << (c & 31)) ? leafOfs : leafOfs+1];
+#endif
+            nodeOfs++;
+            leafOfs += 2;
+        }
+#ifdef HAVE_TEGRA_OPTIMIZATION
+        if( tmp < stage.threshold ) {
+            sum = (double)tmp;
+            return -si;            
+        }
+#else
+        if( sum < stage.threshold )
+            return -si;            
+#endif
+    }
+
+#ifdef HAVE_TEGRA_OPTIMIZATION
+    sum = (double)tmp;
+#endif
+
+    return 1;
+}
+}
+
diff --git a/modules/objdetect/src/datamatrix.cpp b/modules/objdetect/src/datamatrix.cpp
index 9e4623910e..3a8381e2ee 100644
--- a/modules/objdetect/src/datamatrix.cpp
+++ b/modules/objdetect/src/datamatrix.cpp
@@ -191,6 +191,7 @@ CvMat *Sampler::extract()
   return r;
 }
 
+#if CV_SSE2
 static void apron(CvMat *v)
 {
   int r = v->rows;
@@ -331,11 +332,12 @@ static deque<CvPoint> trailto(CvMat *v, int x, int y, CvMat *terminal)
     y += yd;
   }
 
-  int l = r.size() * 9 / 10;
+  int l = (int)(r.size() * 9 / 10);
   while (l--)
     r.pop_front();
   return r;
 }
+#endif
 
 deque <CvDataMatrixCode> cvFindDataMatrix(CvMat *im)
 {
@@ -455,7 +457,7 @@ deque <CvDataMatrixCode> cvFindDataMatrix(CvMat *im)
           }
         }
         if (codes.size() > 0) {
-          printf("searching for more\n");
+          //printf("searching for more\n");
         }
         if (decode(sa, cc)) {
           codes.push_back(cc);
@@ -502,7 +504,7 @@ namespace
     DataMatrixCode operator()(CvDataMatrixCode& cvdm)
     {
       DataMatrixCode dm;
-      std::memcpy(dm.msg,cvdm.msg,sizeof(cvdm.msg));
+      memcpy(dm.msg,cvdm.msg,sizeof(cvdm.msg));
       dm.original = cv::Mat(cvdm.original,true);
       cvReleaseMat(&cvdm.original);
       cv::Mat c(cvdm.corners,true);
diff --git a/modules/objdetect/src/featurepyramid.cpp b/modules/objdetect/src/featurepyramid.cpp
index 111c1fc4e1..8f0e8dbac6 100644
--- a/modules/objdetect/src/featurepyramid.cpp
+++ b/modules/objdetect/src/featurepyramid.cpp
@@ -10,13 +10,6 @@
 #define min(a,b)            (((a) < (b)) ? (a) : (b))
 #endif
 
-static inline int sign(float r)
-{
-    if(r >  0.0001f) return  1;
-    if(r < -0.0001f) return -1;
-    return 0;
-}
-
 /*
 // Getting feature map for the selected subimage
 //
@@ -30,115 +23,132 @@ static inline int sign(float r)
 // RESULT
 // Error status
 */
-int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
+int getFeatureMaps(const IplImage* image, const int k, CvLSVMFeatureMap **map)
 {
     int sizeX, sizeY;
-    int p, px, strsz;
-    int height, width, channels;
+    int p, px, stringSize;
+    int height, width, numChannels;
     int i, j, kk, c, ii, jj, d;
     float  * datadx, * datady;
-    float tmp, x, y, tx, ty;
+    
+    //����� ������ � �����
+    int   ch; 
+    //���������� ���������� ���������
+    float magnitude, x, y, tx, ty;
+    
     IplImage * dx, * dy;
-    int *nearest_x, *nearest_y;
+    int *nearest;
     float *w, a_x, b_x;
 
-    float kernel[3] = {-1.f, 0.f, 1.f}; 
+    // ���� ��� ���������� ���������� ����������� �� ���� x � y
+    float kernel[3] = {-1.f, 0.f, 1.f};
     CvMat kernel_dx = cvMat(1, 3, CV_32F, kernel);
     CvMat kernel_dy = cvMat(3, 1, CV_32F, kernel);
 
+    // �������� ���������
     float * r;
-    int    * alfa;
+    // ����� ������� ���� ������ �������� ���������
+    //     ������ ������� �� ����������� �����������
+    //  �� ������ �������    ����������� �����������
+    int   * alfa;
     
-    float boundary_x[CNTPARTION+1];
-    float boundary_y[CNTPARTION+1];
-    float max, tmp_scal;
-    int    maxi;
+    // ������� ������ ��������
+    float boundary_x[NUM_SECTOR + 1];
+    float boundary_y[NUM_SECTOR + 1];
+    float max, dotProd;
+    int   maxi;
 
-	height = image->height;
-	width  = image->width ;
+    height = image->height;
+    width  = image->width ;
 
-    channels  = image->nChannels;
+    numChannels = image->nChannels;
 
-	dx    = cvCreateImage(cvSize(image->width , image->height) , IPL_DEPTH_32F , 3);
-    dy    = cvCreateImage(cvSize(image->width , image->height) , IPL_DEPTH_32F , 3);
+    dx    = cvCreateImage(cvSize(image->width, image->height), 
+                          IPL_DEPTH_32F, 3);
+    dy    = cvCreateImage(cvSize(image->width, image->height), 
+                          IPL_DEPTH_32F, 3);
 
     sizeX = width  / k;
     sizeY = height / k;
-    px    = CNTPARTION  + 2 * CNTPARTION; // ����������� � �� ����������� �����������
+    px    = 3 * NUM_SECTOR; // ����������� � �� ����������� �����������
     p     = px;
-    strsz = sizeX * p;
-    allocFeatureMapObject(map, sizeX, sizeY, p,  px);
+    stringSize = sizeX * p;
+    allocFeatureMapObject(map, sizeX, sizeY, p);
 
-	cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
-	cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
-	
-    for(i = 0; i <= CNTPARTION; i++)
+    cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
+    cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
+    
+    float arg_vector;
+    for(i = 0; i <= NUM_SECTOR; i++)
     {
-        boundary_x[i] = cosf((((float)i) * (((float)PI) / (float) (CNTPARTION))));
-        boundary_y[i] = sinf((((float)i) * (((float)PI) / (float) (CNTPARTION))));
-    }/*for(i = 0; i <= CNTPARTION; i++) */
+        arg_vector    = ( (float) i ) * ( (float)(PI) / (float)(NUM_SECTOR) );
+        boundary_x[i] = cosf(arg_vector);
+        boundary_y[i] = sinf(arg_vector);
+    }/*for(i = 0; i <= NUM_SECTOR; i++) */
 
     r    = (float *)malloc( sizeof(float) * (width * height));
     alfa = (int   *)malloc( sizeof(int  ) * (width * height * 2));
 
-    for(j = 1; j < height-1; j++)
+    for(j = 1; j < height - 1; j++)
     {
-        datadx = (float*)(dx->imageData + dx->widthStep *j);
-        datady = (float*)(dy->imageData + dy->widthStep *j);
-        for(i = 1; i < width-1; i++)
+        datadx = (float*)(dx->imageData + dx->widthStep * j);
+        datady = (float*)(dy->imageData + dy->widthStep * j);
+        for(i = 1; i < width - 1; i++)
         {
-			c = 0;
-            x = (datadx[i*channels+c]);
-            y = (datady[i*channels+c]);
+            c = 0;
+            x = (datadx[i * numChannels + c]);
+            y = (datady[i * numChannels + c]);
 
-            r[j * width + i] =sqrtf(x*x + y*y);
-            for(kk = 1; kk < channels; kk++)
+            r[j * width + i] =sqrtf(x * x + y * y);
+            for(ch = 1; ch < numChannels; ch++)
             {
-                tx = (datadx[i*channels+kk]);
-                ty = (datady[i*channels+kk]);
-                tmp =sqrtf(tx*tx + ty*ty);
-                if(tmp > r[j * width + i])
+                tx = (datadx[i * numChannels + ch]);
+                ty = (datady[i * numChannels + ch]);
+                magnitude = sqrtf(tx * tx + ty * ty);
+                if(magnitude > r[j * width + i])
                 {
-                    r[j * width + i] = tmp;
-                    c = kk;
+                    r[j * width + i] = magnitude;
+                    c = ch;
                     x = tx;
                     y = ty;
                 }
-            }/*for(kk = 1; kk < channels; kk++)*/
-
+            }/*for(ch = 1; ch < numChannels; ch++)*/
             
-            
-            max  = boundary_x[0]*x + boundary_y[0]*y;
+            max  = boundary_x[0] * x + boundary_y[0] * y;
             maxi = 0;
-            for (kk = 0; kk < CNTPARTION; kk++) {
-                tmp_scal = boundary_x[kk]*x + boundary_y[kk]*y;
-                if (tmp_scal> max) {
-                    max = tmp_scal;
+            for (kk = 0; kk < NUM_SECTOR; kk++) 
+            {
+                dotProd = boundary_x[kk] * x + boundary_y[kk] * y;
+                if (dotProd > max) 
+                {
+                    max  = dotProd;
                     maxi = kk;
-                }else if (-tmp_scal> max) {
-                    max = -tmp_scal;
-                    maxi = kk + CNTPARTION;
+                }
+                else 
+                {
+                    if (-dotProd > max) 
+                    {
+                        max  = -dotProd;
+                        maxi = kk + NUM_SECTOR;
+                    }
                 }
             }
-            alfa[j * width * 2 + i * 2    ] = maxi % CNTPARTION;
+            alfa[j * width * 2 + i * 2    ] = maxi % NUM_SECTOR;
             alfa[j * width * 2 + i * 2 + 1] = maxi;  
         }/*for(i = 0; i < width; i++)*/
     }/*for(j = 0; j < height; j++)*/
 
     //������� ����� � ��������
-    nearest_x = (int *)malloc(sizeof(int) * k);
-    nearest_y = (int *)malloc(sizeof(int) * k);
-    w         = (float*)malloc(sizeof(float) * (k * 2));
+    nearest = (int  *)malloc(sizeof(int  ) *  k);
+    w       = (float*)malloc(sizeof(float) * (k * 2));
     
     for(i = 0; i < k / 2; i++)
     {
-        nearest_x[i] = -1;
-        nearest_y[i] = -1;
+        nearest[i] = -1;
     }/*for(i = 0; i < k / 2; i++)*/
     for(i = k / 2; i < k; i++)
     {
-        nearest_x[i] = 1;
-        nearest_y[i] = 1;
+        nearest[i] = 1;
     }/*for(i = k / 2; i < k; i++)*/
 
     for(j = 0; j < k / 2; j++)
@@ -160,44 +170,52 @@ int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
     //������������
     for(i = 0; i < sizeY; i++)
     {
-        for(j = 0; j < sizeX; j++)
+      for(j = 0; j < sizeX; j++)
+      {
+        for(ii = 0; ii < k; ii++)
         {
-            for(ii = 0; ii < k; ii++)
+          for(jj = 0; jj < k; jj++)
+          {
+            if ((i * k + ii > 0) && 
+                (i * k + ii < height - 1) && 
+                (j * k + jj > 0) && 
+                (j * k + jj < width  - 1))
             {
-                for(jj = 0; jj < k; jj++)
-                {
-					if ((i * k + ii > 0) && (i * k + ii < height - 1) && (j * k + jj > 0) && (j * k + jj < width - 1))
-					{
-						d    =  (k*i + ii)* width + (j*k + jj);
-						(*map)->Map[(i                ) * strsz + (j                ) * (*map)->p + alfa[d * 2    ]             ] += 
-							r[d] * w[ii * 2    ] * w[jj * 2    ];
-						(*map)->Map[(i                ) * strsz + (j                ) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] += 
-							r[d] * w[ii * 2    ] * w[jj * 2    ];
-						if ((i + nearest_y[ii] >= 0) && (i + nearest_y[ii] <= sizeY - 1))
-						{
-							(*map)->Map[(i + nearest_y[ii]) * strsz + (j                ) * (*map)->p + alfa[d * 2    ]             ] += 
-								r[d] * w[ii * 2 + 1] * w[jj * 2    ];
-							(*map)->Map[(i + nearest_y[ii]) * strsz + (j                ) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] += 
-								r[d] * w[ii * 2 + 1] * w[jj * 2    ];
-						}
-						if ((j + nearest_x[jj] >= 0) && (j + nearest_x[jj] <= sizeX - 1))
-						{
-							(*map)->Map[(i                ) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2    ]             ] += 
-								r[d] * w[ii * 2    ] * w[jj * 2 + 1];
-							(*map)->Map[(i                ) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] += 
-								r[d] * w[ii * 2    ] * w[jj * 2 + 1];
-						}
-						if ((i + nearest_y[ii] >= 0) && (i + nearest_y[ii] <= sizeY - 1) && (j + nearest_x[jj] >= 0) && (j + nearest_x[jj] <= sizeX - 1))
-						{
-							(*map)->Map[(i + nearest_y[ii]) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2    ]             ] += 
-								r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
-							(*map)->Map[(i + nearest_y[ii]) * strsz + (j + nearest_x[jj]) * (*map)->p + alfa[d * 2 + 1] + CNTPARTION] += 
-								r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
-						}
-					}
-                }/*for(jj = 0; jj < k; jj++)*/
-            }/*for(ii = 0; ii < k; ii++)*/
-        }/*for(j = 1; j < sizeX - 1; j++)*/
+              d = (k * i + ii) * width + (j * k + jj);
+              (*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2    ]] += 
+                  r[d] * w[ii * 2] * w[jj * 2];
+              (*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2] * w[jj * 2];
+              if ((i + nearest[ii] >= 0) && 
+                  (i + nearest[ii] <= sizeY - 1))
+              {
+                (*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 ];
+                (*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 ];
+              }
+              if ((j + nearest[jj] >= 0) && 
+                  (j + nearest[jj] <= sizeX - 1))
+              {
+                (*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2] * w[jj * 2 + 1];
+                (*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2] * w[jj * 2 + 1];
+              }
+              if ((i + nearest[ii] >= 0) && 
+                  (i + nearest[ii] <= sizeY - 1) && 
+                  (j + nearest[jj] >= 0) && 
+                  (j + nearest[jj] <= sizeX - 1))
+              {
+                (*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2    ]             ] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
+                (*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] += 
+                  r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
+              }
+            }
+          }/*for(jj = 0; jj < k; jj++)*/
+        }/*for(ii = 0; ii < k; ii++)*/
+      }/*for(j = 1; j < sizeX - 1; j++)*/
     }/*for(i = 1; i < sizeY - 1; i++)*/
     
     cvReleaseImage(&dx);
@@ -205,9 +223,8 @@ int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
 
 
     free(w);
-    free(nearest_x);
-    free(nearest_y);
-
+    free(nearest);
+    
     free(r);
     free(alfa);
 
@@ -218,7 +235,7 @@ int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
 // Feature map Normalization and Truncation 
 //
 // API
-// int normalizationAndTruncationFeatureMaps(featureMap *map, const float alfa);
+// int normalizeAndTruncate(featureMap *map, const float alfa);
 // INPUT
 // map               - feature map
 // alfa              - truncation threshold
@@ -227,114 +244,113 @@ int getFeatureMaps_dp(const IplImage* image,const int k, CvLSVMFeatureMap **map)
 // RESULT
 // Error status
 */
-int normalizationAndTruncationFeatureMaps(CvLSVMFeatureMap *map, const float alfa)
+int normalizeAndTruncate(CvLSVMFeatureMap *map, const float alfa)
 {
     int i,j, ii;
     int sizeX, sizeY, p, pos, pp, xp, pos1, pos2;
-    float * part_noma; // norm of C(i, j)
-    float * new_data;
-    float   norm_val;
+    float * partOfNorm; // norm of C(i, j)
+    float * newData;
+    float   valOfNorm;
 
     sizeX     = map->sizeX;
     sizeY     = map->sizeY;
-    part_noma = (float *)malloc (sizeof(float) * (sizeX * sizeY));
+    partOfNorm = (float *)malloc (sizeof(float) * (sizeX * sizeY));
 
-    p = map->xp / 3;
+    p  = NUM_SECTOR;
+    xp = NUM_SECTOR * 3;
+    pp = NUM_SECTOR * 12;
 
     for(i = 0; i < sizeX * sizeY; i++)
     {
-        norm_val = 0.0;
-        pos = i * map->p;
+        valOfNorm = 0.0f;
+        pos = i * map->numFeatures;
         for(j = 0; j < p; j++)
         {
-            norm_val += map->Map[pos + j] * map->Map[pos + j];
+            valOfNorm += map->map[pos + j] * map->map[pos + j];
         }/*for(j = 0; j < p; j++)*/
-        part_noma[i] = norm_val;
+        partOfNorm[i] = valOfNorm;
     }/*for(i = 0; i < sizeX * sizeY; i++)*/
-	
-    xp = map->xp;
-    pp = xp * 4;
+    
     sizeX -= 2;
     sizeY -= 2;
 
-    new_data = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
+    newData = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
 //normalization
     for(i = 1; i <= sizeY; i++)
     {
         for(j = 1; j <= sizeX; j++)
         {
-            norm_val = sqrtf(
-                part_noma[(i    )*(sizeX + 2) + (j    )] +
-                part_noma[(i    )*(sizeX + 2) + (j + 1)] +
-                part_noma[(i + 1)*(sizeX + 2) + (j    )] +
-                part_noma[(i + 1)*(sizeX + 2) + (j + 1)]);
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j + 1)] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j + 1)]);
             pos1 = (i  ) * (sizeX + 2) * xp + (j  ) * xp;
             pos2 = (i-1) * (sizeX    ) * pp + (j-1) * pp;
             for(ii = 0; ii < p; ii++)
             {
-                new_data[pos2 + ii        ] = map->Map[pos1 + ii    ] / norm_val;
+                newData[pos2 + ii        ] = map->map[pos1 + ii    ] / valOfNorm;
             }/*for(ii = 0; ii < p; ii++)*/
             for(ii = 0; ii < 2 * p; ii++)
             {
-                new_data[pos2 + ii + p * 4] = map->Map[pos1 + ii + p] / norm_val;
+                newData[pos2 + ii + p * 4] = map->map[pos1 + ii + p] / valOfNorm;
             }/*for(ii = 0; ii < 2 * p; ii++)*/
-            norm_val = sqrtf(
-                part_noma[(i    )*(sizeX + 2) + (j    )] +
-                part_noma[(i    )*(sizeX + 2) + (j + 1)] +
-                part_noma[(i - 1)*(sizeX + 2) + (j    )] +
-                part_noma[(i - 1)*(sizeX + 2) + (j + 1)]);
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j + 1)] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j + 1)]);
             for(ii = 0; ii < p; ii++)
             {
-                new_data[pos2 + ii + p    ] = map->Map[pos1 + ii    ] / norm_val;
+                newData[pos2 + ii + p    ] = map->map[pos1 + ii    ] / valOfNorm;
             }/*for(ii = 0; ii < p; ii++)*/
             for(ii = 0; ii < 2 * p; ii++)
             {
-                new_data[pos2 + ii + p * 6] = map->Map[pos1 + ii + p] / norm_val;
+                newData[pos2 + ii + p * 6] = map->map[pos1 + ii + p] / valOfNorm;
             }/*for(ii = 0; ii < 2 * p; ii++)*/
-            norm_val = sqrtf(
-                part_noma[(i    )*(sizeX + 2) + (j    )] +
-                part_noma[(i    )*(sizeX + 2) + (j - 1)] +
-                part_noma[(i + 1)*(sizeX + 2) + (j    )] +
-                part_noma[(i + 1)*(sizeX + 2) + (j - 1)]);
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j - 1)] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i + 1)*(sizeX + 2) + (j - 1)]);
             for(ii = 0; ii < p; ii++)
             {
-                new_data[pos2 + ii + p * 2] = map->Map[pos1 + ii    ] / norm_val;
+                newData[pos2 + ii + p * 2] = map->map[pos1 + ii    ] / valOfNorm;
             }/*for(ii = 0; ii < p; ii++)*/
             for(ii = 0; ii < 2 * p; ii++)
             {
-                new_data[pos2 + ii + p * 8] = map->Map[pos1 + ii + p] / norm_val;
+                newData[pos2 + ii + p * 8] = map->map[pos1 + ii + p] / valOfNorm;
             }/*for(ii = 0; ii < 2 * p; ii++)*/
-            norm_val = sqrtf(
-                part_noma[(i    )*(sizeX + 2) + (j    )] +
-                part_noma[(i    )*(sizeX + 2) + (j - 1)] +
-                part_noma[(i - 1)*(sizeX + 2) + (j    )] +
-                part_noma[(i - 1)*(sizeX + 2) + (j - 1)]);
+            valOfNorm = sqrtf(
+                partOfNorm[(i    )*(sizeX + 2) + (j    )] +
+                partOfNorm[(i    )*(sizeX + 2) + (j - 1)] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j    )] +
+                partOfNorm[(i - 1)*(sizeX + 2) + (j - 1)]);
             for(ii = 0; ii < p; ii++)
             {
-                new_data[pos2 + ii + p * 3 ] = map->Map[pos1 + ii    ] / norm_val;
+                newData[pos2 + ii + p * 3 ] = map->map[pos1 + ii    ] / valOfNorm;
             }/*for(ii = 0; ii < p; ii++)*/
             for(ii = 0; ii < 2 * p; ii++)
             {
-                new_data[pos2 + ii + p * 10] = map->Map[pos1 + ii + p] / norm_val;
+                newData[pos2 + ii + p * 10] = map->map[pos1 + ii + p] / valOfNorm;
             }/*for(ii = 0; ii < 2 * p; ii++)*/
         }/*for(j = 1; j <= sizeX; j++)*/
     }/*for(i = 1; i <= sizeY; i++)*/
 //truncation
     for(i = 0; i < sizeX * sizeY * pp; i++)
     {
-        if(new_data [i] > alfa) new_data [i] = alfa;
+        if(newData [i] > alfa) newData [i] = alfa;
     }/*for(i = 0; i < sizeX * sizeY * pp; i++)*/
 //swop data
 
-    map->p  = pp;
-    map->xp = xp;
+    map->numFeatures  = pp;
     map->sizeX = sizeX;
     map->sizeY = sizeY;
 
-    free (map->Map);
-    free (part_noma);
+    free (map->map);
+    free (partOfNorm);
 
-    map->Map = new_data;
+    map->map = newData;
 
     return LATENT_SVM_OK;
 }
@@ -356,21 +372,21 @@ int PCAFeatureMaps(CvLSVMFeatureMap *map)
 { 
     int i,j, ii, jj, k;
     int sizeX, sizeY, p,  pp, xp, yp, pos1, pos2;
-    float * new_data;
+    float * newData;
     float val;
     float nx, ny;
     
     sizeX = map->sizeX;
     sizeY = map->sizeY;
-    p     = map->p;
-    pp    = map->xp + 4;
+    p     = map->numFeatures;
+    pp    = NUM_SECTOR * 3 + 4;
     yp    = 4;
-    xp    = (map->xp / 3);
+    xp    = NUM_SECTOR;
 
     nx    = 1.0f / sqrtf((float)(xp * 2));
     ny    = 1.0f / sqrtf((float)(yp    ));
 
-    new_data = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
+    newData = (float *)malloc (sizeof(float) * (sizeX * sizeY * pp));
 
     for(i = 0; i < sizeY; i++)
     {
@@ -384,9 +400,9 @@ int PCAFeatureMaps(CvLSVMFeatureMap *map)
                 val = 0;
                 for(ii = 0; ii < yp; ii++)
                 {
-                    val += map->Map[pos1 + yp * xp + ii * xp * 2 + jj];
+                    val += map->map[pos1 + yp * xp + ii * xp * 2 + jj];
                 }/*for(ii = 0; ii < yp; ii++)*/
-                new_data[pos2 + k] = val * ny;
+                newData[pos2 + k] = val * ny;
                 k++;
             }/*for(jj = 0; jj < xp * 2; jj++)*/
             for(jj = 0; jj < xp; jj++)
@@ -394,9 +410,9 @@ int PCAFeatureMaps(CvLSVMFeatureMap *map)
                 val = 0;
                 for(ii = 0; ii < yp; ii++)
                 {
-                    val += map->Map[pos1 + ii * xp + jj];
+                    val += map->map[pos1 + ii * xp + jj];
                 }/*for(ii = 0; ii < yp; ii++)*/
-                new_data[pos2 + k] = val * ny;
+                newData[pos2 + k] = val * ny;
                 k++;
             }/*for(jj = 0; jj < xp; jj++)*/
             for(ii = 0; ii < yp; ii++)
@@ -404,25 +420,47 @@ int PCAFeatureMaps(CvLSVMFeatureMap *map)
                 val = 0;
                 for(jj = 0; jj < 2 * xp; jj++)
                 {
-                    val += map->Map[pos1 + yp * xp + ii * xp * 2 + jj];
+                    val += map->map[pos1 + yp * xp + ii * xp * 2 + jj];
                 }/*for(jj = 0; jj < xp; jj++)*/
-                new_data[pos2 + k] = val * nx;
+                newData[pos2 + k] = val * nx;
                 k++;
             } /*for(ii = 0; ii < yp; ii++)*/           
         }/*for(j = 0; j < sizeX; j++)*/
     }/*for(i = 0; i < sizeY; i++)*/
 //swop data
 
-    map->p  = pp;
-    map->xp = pp;
+    map->numFeatures = pp;
 
-    free (map->Map);
+    free (map->map);
 
-    map->Map = new_data;
+    map->map = newData;
 
     return LATENT_SVM_OK;
 }
 
+
+int getPathOfFeaturePyramid(IplImage * image, 
+                            float step, int numStep, int startIndex,
+                            int sideLength, CvLSVMFeaturePyramid **maps)
+{
+    CvLSVMFeatureMap *map;
+    IplImage *scaleTmp;
+    float scale;
+    int   i, err;
+    
+    for(i = 0; i < numStep; i++)
+    {
+        scale = 1.0f / powf(step, (float)i);
+        scaleTmp = resize_opencv (image, scale);
+        err = getFeatureMaps(scaleTmp, sideLength, &map);
+        err = normalizeAndTruncate(map, VAL_OF_TRUNCATE);
+        err = PCAFeatureMaps(map);
+        (*maps)->pyramid[startIndex + i] = map;
+        cvReleaseImage(&scaleTmp);
+    }/*for(i = 0; i < numStep; i++)*/
+    return LATENT_SVM_OK;
+}
+
 /*
 // Getting feature pyramid  
 //
@@ -434,145 +472,52 @@ int PCAFeatureMaps(CvLSVMFeatureMap *map)
                       const int W, const int H, featurePyramid **maps);
 // INPUT
 // image             - image
-// lambda            - resize scale
-// k                 - size of cells
-// startX            - X coordinate of the image rectangle to search
-// startY            - Y coordinate of the image rectangle to search
-// W                 - width of the image rectangle to search
-// H                 - height of the image rectangle to search
 // OUTPUT
 // maps              - feature maps for all levels
 // RESULT
 // Error status
 */
-int getFeaturePyramid(IplImage * image,
-                      const int lambda, const int k, 
-                      const int startX, const int startY, 
-                      const int W, const int H, CvLSVMFeaturePyramid **maps)
+int getFeaturePyramid(IplImage * image, CvLSVMFeaturePyramid **maps)
 {
-    IplImage *img2, *imgTmp, *imgResize;
-    float   step, tmp;
-    int      cntStep;
-    int      maxcall;
-    int i;
-    int err;
-    CvLSVMFeatureMap *map;
+    IplImage *imgResize;
+    float step;
+    int   numStep;
+    int   maxNumCells;
+    int   W, H;
     
-    //geting subimage
-    cvSetImageROI(image, cvRect(startX, startY, W, H));
-    img2 = cvCreateImage(cvGetSize(image), image->depth, image->nChannels);
-    cvCopy(image, img2, NULL);
-    cvResetImageROI(image);
-
-    if(img2->depth != IPL_DEPTH_32F)
+    if(image->depth == IPL_DEPTH_32F)
     {
-        imgResize = cvCreateImage(cvSize(img2->width , img2->height) , IPL_DEPTH_32F , 3);
-        cvConvert(img2, imgResize);
+        imgResize = image;
     }
     else
     {
-        imgResize = img2;
+        imgResize = cvCreateImage(cvSize(image->width , image->height) ,
+                                  IPL_DEPTH_32F , 3);
+        cvConvert(image, imgResize);        
     }
     
-    step = powf(2.0f, 1.0f/ ((float)lambda));
-    maxcall = W/k;
-    if( maxcall > H/k )
+    W = imgResize->width;
+    H = imgResize->height;
+
+    step = powf(2.0f, 1.0f / ((float)LAMBDA));
+    maxNumCells = W / SIDE_LENGTH;
+    if( maxNumCells > H / SIDE_LENGTH )
     {
-        maxcall = H/k;
+        maxNumCells = H / SIDE_LENGTH;
     }
-    cntStep = (int)(logf((float)maxcall/(5.0f))/logf(step)) + 1;
-    //printf("Count step: %f %d\n", step, cntStep);
+    numStep = (int)(logf((float) maxNumCells / (5.0f)) / logf( step )) + 1;
+    
+    allocFeaturePyramidObject(maps, numStep + LAMBDA);
 
-    allocFeaturePyramidObject(maps, lambda, cntStep + lambda);
-
-    for(i = 0; i < lambda; i++)
-    {
-        tmp = 1.0f / powf(step, (float)i);
-        imgTmp = resize_opencv (imgResize, tmp);
-        //imgTmp = resize_article_dp(img2, tmp, 4);
-        err = getFeatureMaps_dp(imgTmp, 4, &map);
-        err = normalizationAndTruncationFeatureMaps(map, 0.2f);
-        err = PCAFeatureMaps(map);
-        (*maps)->pyramid[i] = map;
-        //printf("%d, %d\n", map->sizeY, map->sizeX);
-        cvReleaseImage(&imgTmp);
-    }
-
-    /**********************************one**************/
-    for(i = 0; i <  cntStep; i++)
-    {
-        tmp = 1.0f / powf(step, (float)i);
-        imgTmp = resize_opencv (imgResize, tmp);
-        //imgTmp = resize_article_dp(imgResize, tmp, 8);
-	    err = getFeatureMaps_dp(imgTmp, 8, &map);
-        err = normalizationAndTruncationFeatureMaps(map, 0.2f);
-        err = PCAFeatureMaps(map);
-        (*maps)->pyramid[i + lambda] = map;
-        //printf("%d, %d\n", map->sizeY, map->sizeX);
-		cvReleaseImage(&imgTmp);
-    }/*for(i = 0; i < cntStep; i++)*/
-
-    if(img2->depth != IPL_DEPTH_32F)
+    getPathOfFeaturePyramid(imgResize, step   , LAMBDA, 0, 
+                            SIDE_LENGTH / 2, maps);
+    getPathOfFeaturePyramid(imgResize, step, numStep, LAMBDA, 
+                            SIDE_LENGTH    , maps);
+    
+    if(image->depth != IPL_DEPTH_32F)
     {
         cvReleaseImage(&imgResize);
     }
 
-    cvReleaseImage(&img2);
     return LATENT_SVM_OK;
-}
-
-/*
-// add zero border to feature map
-//
-// API
-// int addBordersToFeatureMaps(featureMap *map, const int bX, const int bY);
-// INPUT
-// map               - feature map
-// bX                - border size in x
-// bY                - border size in y
-// OUTPUT
-// map               - feature map
-// RESULT
-// Error status
-*/
-int addBordersToFeatureMaps(CvLSVMFeatureMap *map, const int bX, const int bY){
-    int i,j, jj;
-    int sizeX, sizeY, p, pos1, pos2;
-    float * new_data;
-    
-    sizeX = map->sizeX;
-    sizeY = map->sizeY;
-    p     = map->p;
-
-    new_data = (float *)malloc (sizeof(float) * ((sizeX + 2 * bX) * (sizeY + 2 * bY) * p));
-
-    for(i = 0; i < ((sizeX + 2 * bX) * (sizeY + 2 * bY) * p); i++)
-    {
-        new_data[i] = (float)0;
-    }/*for(i = 0; i < ((sizeX + 2 * bX) * (sizeY + 2 * bY) * p); i++)*/
-
-    for(i = 0; i < sizeY; i++)
-    {
-        for(j = 0; j < sizeX; j++)
-        {
-
-            pos1 = ((i     )*sizeX            + (j     )) * p;
-            pos2 = ((i + bY)*(sizeX + 2 * bX) + (j + bX)) * p;
-            
-            for(jj = 0; jj < p; jj++)
-            {
-                new_data[pos2 + jj] = map->Map[pos1 + jj];
-            }/*for(jj = 0; jj < p; jj++)*/
-        }/*for(j = 0; j < sizeX; j++)*/
-    }/*for(i = 0; i < sizeY; i++)*/
-    //swop data
-
-    map->sizeX = sizeX + 2 * bX;
-    map->sizeY = sizeY + 2 * bY;
-    
-    free (map->Map);
-
-    map->Map = new_data;
-
-    return LATENT_SVM_OK;
-}
+}
\ No newline at end of file
diff --git a/modules/objdetect/src/haar.cpp b/modules/objdetect/src/haar.cpp
index 001ed1e680..6ff21c6090 100644
--- a/modules/objdetect/src/haar.cpp
+++ b/modules/objdetect/src/haar.cpp
@@ -850,6 +850,10 @@ struct HaarDetectObjects_ScaleImage_Invoker
         Size winSize0 = cascade->orig_window_size;
         Size winSize(cvRound(winSize0.width*factor), cvRound(winSize0.height*factor));
         int y1 = range.begin()*stripSize, y2 = min(range.end()*stripSize, sum1.rows - 1 - winSize0.height);
+        
+        if (y2 <= y1 || sum1.cols <= 1 + winSize0.width)
+            return;
+        
         Size ssz(sum1.cols - 1 - winSize0.width, y2 - y1);
         int x, y, ystep = factor > 2 ? 1 : 2;
         
@@ -1033,12 +1037,6 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
     bool findBiggestObject = (flags & CV_HAAR_FIND_BIGGEST_OBJECT) != 0;
     bool roughSearch = (flags & CV_HAAR_DO_ROUGH_SEARCH) != 0;
 
-    if( maxSize.height == 0 || maxSize.width == 0 )
-    {
-        maxSize.height = img->rows;
-        maxSize.width = img->cols;
-    }
-
     if( !CV_IS_HAAR_CLASSIFIER(cascade) )
         CV_Error( !cascade ? CV_StsNullPtr : CV_StsBadArg, "Invalid classifier cascade" );
 
@@ -1057,6 +1055,12 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
 
     if( findBiggestObject )
         flags &= ~CV_HAAR_SCALE_IMAGE;
+    
+    if( maxSize.height == 0 || maxSize.width == 0 )
+    {
+        maxSize.height = img->rows;
+        maxSize.width = img->cols;
+    }
 
     temp = cvCreateMat( img->rows, img->cols, CV_8UC1 );
     sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_32SC1 );
diff --git a/modules/objdetect/src/latentsvm.cpp b/modules/objdetect/src/latentsvm.cpp
index f93ee5fef0..c11f51e08f 100644
--- a/modules/objdetect/src/latentsvm.cpp
+++ b/modules/objdetect/src/latentsvm.cpp
@@ -127,8 +127,7 @@ CvLSVMFeaturePyramid* createFeaturePyramidWithBorder(IplImage *image,
     CvLSVMFeaturePyramid *H;
 
     // Obtaining feature pyramid
-    opResult = getFeaturePyramid(image, LAMBDA, SIDE_LENGTH, 0, 0, 
-                                 image->width, image->height, &H);
+    opResult = getFeaturePyramid(image, &H);
 
     if (opResult != LATENT_SVM_OK)
     {
@@ -139,7 +138,7 @@ CvLSVMFeaturePyramid* createFeaturePyramidWithBorder(IplImage *image,
     // Addition nullable border for each feature map
     // the size of the border for root filters
     computeBorderSize(maxXBorder, maxYBorder, &bx, &by);
-    for (level = 0; level < H->countLevel; level++)
+    for (level = 0; level < H->numLevels; level++)
     {
         addNullableBorder(H->pyramid[level], bx, by);
     }
@@ -196,7 +195,7 @@ int searchObject(const CvLSVMFeaturePyramid *H, const CvLSVMFilterObject **all_F
     // Transformation filter displacement from the block space 
     // to the space of pixels at the initial image
     // that settles at the level number LAMBDA
-    convertPoints(H->countLevel, H->lambda, LAMBDA, (*points), 
+    convertPoints(H->numLevels, LAMBDA, LAMBDA, (*points), 
                   (*levels), (*partsDisplacement), (*kPoints), n, 
                   maxXBorder, maxYBorder);
 
@@ -305,7 +304,7 @@ int searchObjectThreshold(const CvLSVMFeaturePyramid *H,
     // Transformation filter displacement from the block space 
     // to the space of pixels at the initial image
     // that settles at the level number LAMBDA
-    convertPoints(H->countLevel, H->lambda, LAMBDA, (*points), 
+    convertPoints(H->numLevels, LAMBDA, LAMBDA, (*points), 
                   (*levels), (*partsDisplacement), (*kPoints), n, 
                   maxXBorder, maxYBorder);
 
@@ -509,11 +508,11 @@ int getMaxFilterDims(const CvLSVMFilterObject **filters, int kComponents,
     componentIndex = kPartFilters[0] + 1;
     for (i = 1; i < kComponents; i++)
     {
-        if (filters[componentIndex]->sizeX > *maxXBorder)
+        if ((unsigned)filters[componentIndex]->sizeX > *maxXBorder)
         {
             *maxXBorder = filters[componentIndex]->sizeX;
         }
-        if (filters[componentIndex]->sizeY > *maxYBorder)
+        if ((unsigned)filters[componentIndex]->sizeY > *maxYBorder)
         {
             *maxYBorder = filters[componentIndex]->sizeY;
         }
diff --git a/modules/objdetect/src/lsvmparser.cpp b/modules/objdetect/src/lsvmparser.cpp
index 83a326dca2..49724a59d4 100644
--- a/modules/objdetect/src/lsvmparser.cpp
+++ b/modules/objdetect/src/lsvmparser.cpp
@@ -658,8 +658,7 @@ void parserModel(FILE * xmlf, CvLSVMFilterObject *** model, int *last, int *max,
                 if(tagVal == EMODEL){
                     //printf("</Model>\n");
                     for(ii = 0; ii <= *last; ii++){
-                        (*model)[ii]->p = p;
-                        (*model)[ii]->xp = 9;
+                        (*model)[ii]->numFeatures = p;
                     }
                     * count = N_comp;
                     return;
@@ -672,11 +671,11 @@ void parserModel(FILE * xmlf, CvLSVMFilterObject *** model, int *last, int *max,
                         * b    = bb;
                         * count = N_comp + 1; 
                     } else {
-                        cmp = (int    *)malloc(sizeof(int)    * (N_comp + 1));
+                        cmp = (int   *)malloc(sizeof(int)   * (N_comp + 1));
                         bb  = (float *)malloc(sizeof(float) * (N_comp + 1));
                         for(ii = 0; ii < N_comp; ii++){
-                            cmp[i] = (* comp)[ii];
-                            bb [i] = (* b   )[ii];
+                            cmp[ii] = (* comp)[ii];
+                            bb [ii] = (* b   )[ii];
                         }
                         free(* comp);
                         free(* b   );
diff --git a/modules/objdetect/src/lsvmtbbversion.cpp b/modules/objdetect/src/lsvmtbbversion.cpp
index bac48acae6..3c87930d31 100644
--- a/modules/objdetect/src/lsvmtbbversion.cpp
+++ b/modules/objdetect/src/lsvmtbbversion.cpp
@@ -46,7 +46,7 @@ public:
         for (i = 0; i < kLevels; i++)
         {
             level = procLevels[i];
-            partsLevel = level - H->lambda;
+            partsLevel = level - LAMBDA;//H->lambda;
             res = thresholdFunctionalScoreFixedLevel(
                 filters, n, H, level, b,
                 maxXBorder, maxYBorder, scoreThreshold, &(score[partsLevel]), 
diff --git a/modules/objdetect/src/matching.cpp b/modules/objdetect/src/matching.cpp
index 9fceaa1f80..d673c9319f 100644
--- a/modules/objdetect/src/matching.cpp
+++ b/modules/objdetect/src/matching.cpp
@@ -33,7 +33,7 @@ int convolution(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *map, float
 	m1 = map->sizeX;
 	n2 = Fi->sizeY;
 	m2 = Fi->sizeX;
-	p = map->p;
+	p = map->numFeatures;
 
 	diff1 = n1 - n2 + 1;
 	diff2 = m1 - m2 + 1;
@@ -51,7 +51,7 @@ int convolution(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap *map, float
 			{
 				for (j2 = 0; j2 < m2; j2++)
 				{
-					pMap = map->Map + (i1 + i2) * m1 * p + (j1 + j2) * p;//sm2
+					pMap = map->map + (i1 + i2) * m1 * p + (j1 + j2) * p;//sm2
 					pH = Fi->H + (i2 * m2 + j2) * p;//sm2
 					for (k = 0; k < p/4; k++)
 					{
@@ -202,22 +202,21 @@ int getFFTImageFilterObject(const CvLSVMFilterObject *filter,
                             int mapDimX, int mapDimY,
                             CvLSVMFftImage **image)
 {
-    unsigned int i, mapSize, filterSize;
-    int res;
+    int i, mapSize, filterSize, res;
     float *newFilter, *rot2PIFilter;    
     
     filterSize = filter->sizeX * filter->sizeY;
     mapSize = mapDimX * mapDimY;
     newFilter = (float *)malloc(sizeof(float) * (2 * mapSize));
     rot2PIFilter = (float *)malloc(sizeof(float) * filterSize);
-    res = allocFFTImage(image, filter->p, mapDimX, mapDimY);
+    res = allocFFTImage(image, filter->numFeatures, mapDimX, mapDimY);
     if (res != LATENT_SVM_OK)
     {
         return res;
     }
-    for (i = 0; i < filter->p; i++)
+    for (i = 0; i < filter->numFeatures; i++)
     {        
-        rot2PI(filter->H, filter->sizeX, filter->sizeY, rot2PIFilter, filter->p, i);
+        rot2PI(filter->H, filter->sizeX, filter->sizeY, rot2PIFilter, filter->numFeatures, i);
         addNullableBars(rot2PIFilter, filter->sizeX, filter->sizeY, 
                         newFilter, mapDimX, mapDimY);
         fft2d(newFilter, (*image)->channels[i], mapDimY, mapDimX);
@@ -241,14 +240,14 @@ int getFFTImageFeatureMap(const CvLSVMFeatureMap *map, CvLSVMFftImage **image)
 {
     int i, j, size;
     float *buf;    
-    allocFFTImage(image, map->p, map->sizeX, map->sizeY);
+    allocFFTImage(image, map->numFeatures, map->sizeX, map->sizeY);
     size = map->sizeX * map->sizeY;
     buf = (float *)malloc(sizeof(float) * (2 * size));
-    for (i = 0; i < map->p; i++)
+    for (i = 0; i < map->numFeatures; i++)
     {
         for (j = 0; j < size; j++)
         {
-            buf[2 * j] = map->Map[j * map->p + i];
+            buf[2 * j] = map->map[j * map->numFeatures + i];
             buf[2 * j + 1] = 0.0;
         }
         fft2d(buf, (*image)->channels[i], map->sizeY, map->sizeX);
@@ -282,7 +281,7 @@ int convFFTConv2d(const CvLSVMFftImage *featMapImage, const CvLSVMFftImage *filt
     imagesMultRes = (float *)malloc(sizeof(float) * size);
     fftImagesMulti(featMapImage->channels[0], filterImage->channels[0], 
             featMapImage->dimY, featMapImage->dimX, imagesMultRes);
-    for (i = 1; (i < (int)featMapImage->p) && (i < (int)filterImage->p); i++)
+    for (i = 1; (i < (int)featMapImage->numFeatures) && (i < (int)filterImage->numFeatures); i++)
     {
         fftImagesMulti(featMapImage->channels[i],filterImage->channels[i], 
             featMapImage->dimY, featMapImage->dimX, imagesMult);
@@ -343,7 +342,7 @@ int filterDispositionLevel(const CvLSVMFilterObject *Fi, const CvLSVMFeatureMap
     m1 = pyramid->sizeX;
     n2 = Fi->sizeY;
     m2 = Fi->sizeX;
-    p = pyramid->p;
+    p = pyramid->numFeatures;
     (*scoreFi) = NULL;
     (*pointsX) = NULL;
     (*pointsY) = NULL;
@@ -429,7 +428,7 @@ int filterDispositionLevelFFT(const CvLSVMFilterObject *Fi, const CvLSVMFftImage
     m1 = featMapImage->dimX;
     n2 = Fi->sizeY;
     m2 = Fi->sizeX;
-    p = featMapImage->p;
+    p = featMapImage->numFeatures;
     (*scoreFi) = NULL;
     (*pointsX) = NULL;
     (*pointsY) = NULL;
@@ -525,8 +524,8 @@ int addNullableBorder(CvLSVMFeatureMap *map, int bx, int by)
     float *new_map;
     sizeX = map->sizeX + 2 * bx;
     sizeY = map->sizeY + 2 * by;
-    new_map = (float *)malloc(sizeof(float) * sizeX * sizeY * map->p);
-    for (i = 0; i < sizeX * sizeY * map->p; i++)
+    new_map = (float *)malloc(sizeof(float) * sizeX * sizeY * map->numFeatures);
+    for (i = 0; i < sizeX * sizeY * map->numFeatures; i++)
     {
         new_map[i] = 0.0;
     }
@@ -534,17 +533,17 @@ int addNullableBorder(CvLSVMFeatureMap *map, int bx, int by)
     {
         for (j = bx; j < map->sizeX + bx; j++)
         {
-            for (k = 0; k < map->p; k++)
+            for (k = 0; k < map->numFeatures; k++)
             {
-                new_map[(i * sizeX + j) * map->p + k] = 
-                    map->Map[((i - by) * map->sizeX + j - bx) * map->p + k];
+                new_map[(i * sizeX + j) * map->numFeatures + k] = 
+                    map->map[((i - by) * map->sizeX + j - bx) * map->numFeatures + k];
             }
         }
     }
     map->sizeX = sizeX;
     map->sizeY = sizeY;
-    free(map->Map);
-    map->Map = new_map;
+    free(map->map);
+    map->map = new_map;
     return LATENT_SVM_OK;
 }
 
@@ -558,19 +557,19 @@ CvLSVMFeatureMap* featureMapBorderPartFilter(CvLSVMFeatureMap *map,
     computeBorderSize(maxXBorder, maxYBorder, &bx, &by);
     sizeX = map->sizeX + 2 * bx;
     sizeY = map->sizeY + 2 * by;
-    allocFeatureMapObject(&new_map, sizeX, sizeY, map->p, map->xp);
-    for (i = 0; i < sizeX * sizeY * map->p; i++)
+    allocFeatureMapObject(&new_map, sizeX, sizeY, map->numFeatures);
+    for (i = 0; i < sizeX * sizeY * map->numFeatures; i++)
     {
-        new_map->Map[i] = 0.0;
+        new_map->map[i] = 0.0f;
     }
     for (i = by; i < map->sizeY + by; i++)
     {
         for (j = bx; j < map->sizeX + bx; j++)
         {
-            for (k = 0; k < map->p; k++)
+            for (k = 0; k < map->numFeatures; k++)
             {
-                new_map->Map[(i * sizeX + j) * map->p + k] = 
-                    map->Map[((i - by) * map->sizeX + j - bx) * map->p + k];
+                new_map->map[(i * sizeX + j) * map->numFeatures + k] = 
+                    map->map[((i - by) * map->sizeX + j - bx) * map->numFeatures + k];
             }
         }
     }
@@ -640,7 +639,7 @@ int maxFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n,
     dimY = H->pyramid[level]->sizeY;
 
     // Number of features
-    p = H->pyramid[level]->p;
+    p = H->pyramid[level]->numFeatures;
         
     // Getting dimension of root filter
     nF0 = all_F[0]->sizeY;
@@ -888,7 +887,7 @@ int thresholdFunctionalScoreFixedLevel(const CvLSVMFilterObject **all_F, int n,
     dimY = H->pyramid[level]->sizeY;
 
     // Number of features
-    p = H->pyramid[level]->p;
+    p = H->pyramid[level]->numFeatures;
         
     // Getting dimension of root filter
     nF0 = all_F[0]->sizeY;
@@ -1109,7 +1108,7 @@ int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     // Computation the number of levels for seaching object,
     // first lambda-levels are used for computation values
     // of score function for each position of root filter
-    numLevels = H->countLevel - H->lambda;
+    numLevels = H->numLevels - LAMBDA;
     
     // Allocation memory for maximum value of score function for each level
     tmpScore = (float *)malloc(sizeof(float) * numLevels);        
@@ -1135,7 +1134,7 @@ int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     }
 
     // Set current value of the maximum of score function
-    res = maxFunctionalScoreFixedLevel(all_F, n, H, H->lambda, b, 
+    res = maxFunctionalScoreFixedLevel(all_F, n, H, LAMBDA, b, 
             maxXBorder, maxYBorder,
             &(tmpScore[0]), 
             tmpPoints[0], 
@@ -1150,9 +1149,9 @@ int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     file = fopen("maxScore.csv", "w+");
     fprintf(file, "%i;%lf;\n", H->lambda, tmpScore[0]);    
     //*/
-    for (l = H->lambda + 1; l < H->countLevel; l++)
+    for (l = LAMBDA + 1; l < H->numLevels; l++)
     {        
-        k = l - H->lambda;
+        k = l - LAMBDA;
         res = maxFunctionalScoreFixedLevel(all_F, n, H, l, b,
                                            maxXBorder, maxYBorder,
                                            &(tmpScore[k]), 
@@ -1191,7 +1190,7 @@ int maxFunctionalScore(const CvLSVMFilterObject **all_F, int n,
         if ((tmpScore[i] - maxScore) * (tmpScore[i] - maxScore) <= EPS)
         {
             // Computation the number of level
-            level = i + H->lambda; 
+            level = i + LAMBDA; 
 
             // Addition a set of points
             f += tmpKPoints[i];
@@ -1272,7 +1271,7 @@ int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     // Computation the number of levels for seaching object,
     // first lambda-levels are used for computation values
     // of score function for each position of root filter
-    numLevels = H->countLevel - H->lambda;
+    numLevels = H->numLevels - LAMBDA;
     
     // Allocation memory for values of score function for each level
     // that exceed threshold
@@ -1305,9 +1304,9 @@ int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     fprintf(file, "%i;%lf;\n", H->lambda, tmpScore[0]);    
     //*/
     (*kPoints) = 0;
-    for (l = H->lambda; l < H->countLevel; l++)
+    for (l = LAMBDA; l < H->numLevels; l++)
     {        
-        k = l - H->lambda;
+        k = l - LAMBDA;
         //printf("Score at the level %i\n", l);
         res = thresholdFunctionalScoreFixedLevel(all_F, n, H, l, b, 
             maxXBorder, maxYBorder, scoreThreshold,
@@ -1339,7 +1338,7 @@ int thresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     for (i = 0; i < numLevels; i++)
     {
         // Computation the number of level
-        level = i + H->lambda; 
+        level = i + LAMBDA; 
 
         // Addition a set of points
         f += tmpKPoints[i];
@@ -1411,7 +1410,7 @@ int createSchedule(const CvLSVMFeaturePyramid *H, const CvLSVMFilterObject **all
         sumPartFiltersDim += all_F[i]->sizeX * all_F[i]->sizeY;
     }
     // Number of levels which are used for computation of score function
-    numLevels = H->countLevel - H->lambda;
+    numLevels = H->numLevels - LAMBDA;
     // Allocation memory for saving number of dot products that will be
     // computed for each level of feature pyramid
     dotProd = (int *)malloc(sizeof(int) * numLevels);
@@ -1421,7 +1420,7 @@ int createSchedule(const CvLSVMFeaturePyramid *H, const CvLSVMFilterObject **all
     dby = 2 * by;
     // Total number of dot products for all levels
     numDotProducts = 0;
-    lambda = H->lambda;
+    lambda = LAMBDA;
     for (i = 0; i < numLevels; i++)
     {
         dotProd[i] = H->pyramid[i + lambda]->sizeX * 
@@ -1575,8 +1574,7 @@ int tbbThresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     // Computation the number of levels for seaching object,
     // first lambda-levels are used for computation values
     // of score function for each position of root filter
-    numLevels = H->countLevel - H->lambda;
-
+    numLevels = H->numLevels - LAMBDA;
     kLevels = (int *)malloc(sizeof(int) * threadsNum);
     procLevels = (int **)malloc(sizeof(int*) * threadsNum);
     computeBorderSize(maxXBorder, maxYBorder, &bx, &by);
@@ -1646,7 +1644,7 @@ int tbbThresholdFunctionalScore(const CvLSVMFilterObject **all_F, int n,
     for (i = 0; i < numLevels; i++)
     {
         // Computation the number of level
-        level = i + H->lambda; 
+        level = i + LAMBDA;//H->lambda; 
 
         // Addition a set of points
         f += tmpKPoints[i];
diff --git a/modules/objdetect/src/routine.cpp b/modules/objdetect/src/routine.cpp
index 256aa9e24c..4ba89c6830 100644
--- a/modules/objdetect/src/routine.cpp
+++ b/modules/objdetect/src/routine.cpp
@@ -1,13 +1,14 @@
 #include "precomp.hpp"
 #include "_lsvm_routine.h"
 
-int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX, const int sizeY, const int p, const int xp){
+int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX,
+                      const int sizeY, const int numFeatures) 
+{
     int i;
     (*obj) = (CvLSVMFilterObject *)malloc(sizeof(CvLSVMFilterObject));
-    (*obj)->sizeX = sizeX;
-    (*obj)->sizeY = sizeY;
-    (*obj)->p     = p    ;
-    (*obj)->xp    = xp   ;
+    (*obj)->sizeX           = sizeX;
+    (*obj)->sizeY           = sizeY;
+    (*obj)->numFeatures     = numFeatures;
     (*obj)->fineFunction[0] = 0.0f;
     (*obj)->fineFunction[1] = 0.0f;
     (*obj)->fineFunction[2] = 0.0f;
@@ -15,75 +16,87 @@ int allocFilterObject(CvLSVMFilterObject **obj, const int sizeX, const int sizeY
     (*obj)->V.x         = 0;
     (*obj)->V.y         = 0;
     (*obj)->V.l         = 0;
-    (*obj)->H = (float *) malloc(sizeof (float) * (sizeX * sizeY * p));
-    for(i = 0; i < sizeX * sizeY * p; i++){
+    (*obj)->H = (float *) malloc(sizeof (float) * 
+                                (sizeX * sizeY  * numFeatures));
+    for(i = 0; i < sizeX * sizeY * numFeatures; i++)
+    {
         (*obj)->H[i] = 0.0f;
     }
     return LATENT_SVM_OK;
 }
-int freeFilterObject (CvLSVMFilterObject **obj){
-    if(*obj == NULL) return 0;
+int freeFilterObject (CvLSVMFilterObject **obj)
+{
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
     free((*obj)->H);
     free(*obj);
     (*obj) = NULL;
     return LATENT_SVM_OK;
 }
 
-int allocFeatureMapObject(CvLSVMFeatureMap **obj, const int sizeX, const int sizeY, const int p, const int xp){
+int allocFeatureMapObject(CvLSVMFeatureMap **obj, const int sizeX, 
+                          const int sizeY, const int numFeatures)
+{
     int i;
     (*obj) = (CvLSVMFeatureMap *)malloc(sizeof(CvLSVMFeatureMap));
-    (*obj)->sizeX = sizeX;
-    (*obj)->sizeY = sizeY;
-    (*obj)->p     = p    ;
-    (*obj)->xp    = xp   ;
-    (*obj)->Map = (float *) malloc(sizeof (float) * (sizeX * sizeY * p));
-    for(i = 0; i < sizeX * sizeY * p; i++){
-        (*obj)->Map[i] = 0.0;
+    (*obj)->sizeX       = sizeX;
+    (*obj)->sizeY       = sizeY;
+    (*obj)->numFeatures = numFeatures;
+    (*obj)->map = (float *) malloc(sizeof (float) * 
+                                  (sizeX * sizeY  * numFeatures));
+    for(i = 0; i < sizeX * sizeY * numFeatures; i++)
+    {
+        (*obj)->map[i] = 0.0f;
     }
     return LATENT_SVM_OK;
 }
-int freeFeatureMapObject (CvLSVMFeatureMap **obj){
-    if(*obj == NULL) return 0;
-    free((*obj)->Map);
+int freeFeatureMapObject (CvLSVMFeatureMap **obj)
+{
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
+    free((*obj)->map);
     free(*obj);
     (*obj) = NULL;
     return LATENT_SVM_OK;
 }
 
-int allocFeaturePyramidObject(CvLSVMFeaturePyramid **obj, const int lambda, const int countLevel){
+int allocFeaturePyramidObject(CvLSVMFeaturePyramid **obj,
+                              const int numLevels) 
+{
     (*obj) = (CvLSVMFeaturePyramid *)malloc(sizeof(CvLSVMFeaturePyramid));
-    (*obj)->countLevel = countLevel;
-    (*obj)->pyramid    = (CvLSVMFeatureMap **)malloc(sizeof(CvLSVMFeatureMap *) * countLevel);
-    (*obj)->lambda     = lambda;
+    (*obj)->numLevels = numLevels;
+    (*obj)->pyramid    = (CvLSVMFeatureMap **)malloc(
+                         sizeof(CvLSVMFeatureMap *) * numLevels);
     return LATENT_SVM_OK;
 }
 
-int freeFeaturePyramidObject (CvLSVMFeaturePyramid **obj){
+int freeFeaturePyramidObject (CvLSVMFeaturePyramid **obj)
+{
     int i; 
-    if(*obj == NULL) return 0;
-    for(i = 0; i < (*obj)->countLevel; i++)
+    if(*obj == NULL) return LATENT_SVM_MEM_NULL;
+    for(i = 0; i < (*obj)->numLevels; i++)
+    {
         freeFeatureMapObject(&((*obj)->pyramid[i]));
+    }
     free((*obj)->pyramid);
     free(*obj);
     (*obj) = NULL;
     return LATENT_SVM_OK;
 }
 
-int allocFFTImage(CvLSVMFftImage **image, int p, int dimX, int dimY)
+int allocFFTImage(CvLSVMFftImage **image, int numFeatures, int dimX, int dimY)
 {
     int i, j, size;
     *image = (CvLSVMFftImage *)malloc(sizeof(CvLSVMFftImage));
-    (*image)->p = p;
-    (*image)->dimX = dimX;
-    (*image)->dimY = dimY;
-    (*image)->channels = (float **)malloc(sizeof(float *) * p);
+    (*image)->numFeatures = numFeatures;
+    (*image)->dimX         = dimX;
+    (*image)->dimY         = dimY;
+    (*image)->channels     = (float **)malloc(sizeof(float *) * numFeatures);
     size = 2 * dimX * dimY;
-    for (i = 0; i < p; i++)
+    for (i = 0; i < numFeatures; i++)
     {
         (*image)->channels[i] = (float *)malloc(sizeof(float) * size);
         for (j = 0; j < size; j++)
         {
-            (*image)->channels[i][j] = 0.0;
+            (*image)->channels[i][j] = 0.0f;
         }
     }
     return LATENT_SVM_OK;
@@ -91,9 +104,9 @@ int allocFFTImage(CvLSVMFftImage **image, int p, int dimX, int dimY)
 
 int freeFFTImage(CvLSVMFftImage **image)
 {
-    unsigned i;
+    int i;
     if (*image == NULL) return LATENT_SVM_OK;
-    for (i = 0; i < (*image)->p; i++)
+    for (i = 0; i < (*image)->numFeatures; i++)
     {
         free((*image)->channels[i]);
         (*image)->channels[i] = NULL;
diff --git a/modules/python/CMakeLists.txt b/modules/python/CMakeLists.txt
index ce21d22840..196c99f9e7 100644
--- a/modules/python/CMakeLists.txt
+++ b/modules/python/CMakeLists.txt
@@ -5,9 +5,9 @@ project(opencv_python)
 
 include_directories(${PYTHON_INCLUDE_PATH})
 include_directories(
-    "${CMAKE_CURRENT_SOURCE_DIR}/src1"
     "${CMAKE_CURRENT_SOURCE_DIR}/src2"
     "${OpenCV_SOURCE_DIR}/modules/core/include"
+    "${OpenCV_SOURCE_DIR}/modules/flann/include"
     "${OpenCV_SOURCE_DIR}/modules/imgproc/include"
     "${OpenCV_SOURCE_DIR}/modules/video/include"
     "${OpenCV_SOURCE_DIR}/modules/highgui/include"
@@ -23,6 +23,7 @@ include_directories(
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 set(opencv_hdrs "${OpenCV_SOURCE_DIR}/modules/core/include/opencv2/core/core.hpp"
+    "${OpenCV_SOURCE_DIR}/modules/flann/include/opencv2/flann/miniflann.hpp"
     "${OpenCV_SOURCE_DIR}/modules/imgproc/include/opencv2/imgproc/imgproc.hpp"
     "${OpenCV_SOURCE_DIR}/modules/video/include/opencv2/video/background_segm.hpp"
     "${OpenCV_SOURCE_DIR}/modules/video/include/opencv2/video/tracking.hpp"
@@ -30,44 +31,12 @@ set(opencv_hdrs "${OpenCV_SOURCE_DIR}/modules/core/include/opencv2/core/core.hpp
     "${OpenCV_SOURCE_DIR}/modules/ml/include/opencv2/ml/ml.hpp"
     "${OpenCV_SOURCE_DIR}/modules/features2d/include/opencv2/features2d/features2d.hpp"
     "${OpenCV_SOURCE_DIR}/modules/calib3d/include/opencv2/calib3d/calib3d.hpp"
-    "${OpenCV_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp"
-    "${OpenCV_SOURCE_DIR}/modules/python/src2/opencv_extra_api.hpp")
+    "${OpenCV_SOURCE_DIR}/modules/objdetect/include/opencv2/objdetect/objdetect.hpp")
 
 if(MSVC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
 endif()
 
-add_custom_command(
-   OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generated0.i
-   COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src1/gen.py" "${CMAKE_CURRENT_SOURCE_DIR}/src1"
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/api
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/defs
-   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src1/gen.py
-   )
-
-
-set(cv_target "opencv_python")
-add_library(${cv_target} SHARED src1/cv.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated0.i)
-target_link_libraries(${cv_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
-    
-set_target_properties(${cv_target} PROPERTIES PREFIX "")
-set_target_properties(${cv_target} PROPERTIES OUTPUT_NAME "cv")
-
-execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import distutils.sysconfig; print distutils.sysconfig.get_config_var('SO')"
-                RESULT_VARIABLE PYTHON_CVPY_PROCESS
-                OUTPUT_VARIABLE CVPY_SUFFIX
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-set_target_properties(${cv_target} PROPERTIES SUFFIX ${CVPY_SUFFIX})
-
-if (MSVC AND NOT BUILD_SHARED_LIBS)
-    set_target_properties(${cv_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
-endif()
-
-set(cvpymodules ${cv_target})
-
-if(PYTHON_USE_NUMPY)
-
 set(cv2_generated_hdrs
     "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_funcs.h"
     "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_func_tab.h"
@@ -75,28 +44,41 @@ set(cv2_generated_hdrs
     "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_type_reg.h"
     "${CMAKE_CURRENT_BINARY_DIR}/pyopencv_generated_const_reg.h")
 
+
 add_custom_command(
-      OUTPUT ${cv2_generated_hdrs}
-      COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py" ${CMAKE_CURRENT_BINARY_DIR} ${opencv_hdrs}
-      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py
-      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/hdr_parser.py
-      DEPENDS ${opencv_hdrs})
+   OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/generated0.i
+   COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src2/gen.py" "${CMAKE_CURRENT_SOURCE_DIR}/src2"
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/api
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/defs
+   DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/gen.py
+   )
 
-set(cv2_target "opencv2_python")
-add_library(${cv2_target} SHARED src2/cv2.cpp src2/opencv_extra_api.hpp ${cv2_generated_hdrs})
-target_link_libraries(${cv2_target} ${PYTHON_LIBRARIES} opencv_core opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
+add_custom_command(
+     OUTPUT ${cv2_generated_hdrs}
+     COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py" ${CMAKE_CURRENT_BINARY_DIR} ${opencv_hdrs}
+     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/gen2.py
+     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src2/hdr_parser.py
+     DEPENDS ${opencv_hdrs})
 
+set(cv2_target "opencv_python")
+add_library(${cv2_target} SHARED src2/cv2.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated0.i ${cv2_generated_hdrs} src2/cv2.cv.hpp)
+target_link_libraries(${cv2_target} ${PYTHON_LIBRARIES} opencv_core opencv_flann opencv_imgproc opencv_video opencv_ml opencv_features2d opencv_highgui opencv_calib3d opencv_objdetect opencv_legacy opencv_contrib)
+    
 set_target_properties(${cv2_target} PROPERTIES PREFIX "")
 set_target_properties(${cv2_target} PROPERTIES OUTPUT_NAME "cv2")
+
+execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import distutils.sysconfig; print distutils.sysconfig.get_config_var('SO')"
+                RESULT_VARIABLE PYTHON_CVPY_PROCESS
+                OUTPUT_VARIABLE CVPY_SUFFIX
+                OUTPUT_STRIP_TRAILING_WHITESPACE)
+
 set_target_properties(${cv2_target} PROPERTIES SUFFIX ${CVPY_SUFFIX})
 
 if (MSVC AND NOT BUILD_SHARED_LIBS)
     set_target_properties(${cv2_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
 endif()
 
-set(cvpymodules ${cvpymodules} ${cv2_target})
-
-endif()
+set(cvpymodules ${cv2_target})
 
 if(WIN32)
   install(TARGETS ${cvpymodules}
@@ -105,7 +87,6 @@ if(WIN32)
           ARCHIVE DESTINATION "Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages" COMPONENT main
           )
 else()
-  #install(FILES ${LIBRARY_OUTPUT_PATH}/cv${CVPY_SUFFIX} DESTINATION ${PYTHON_PACKAGES_PATH})
   install(TARGETS ${cvpymodules} 
           RUNTIME DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
           LIBRARY DESTINATION ${PYTHON_PACKAGES_PATH} COMPONENT main
diff --git a/modules/python/src1/api b/modules/python/src2/api
similarity index 99%
rename from modules/python/src1/api
rename to modules/python/src2/api
index 9936407704..c760ec2248 100644
--- a/modules/python/src1/api
+++ b/modules/python/src2/api
@@ -1342,6 +1342,7 @@ GetOptimalNewCameraMatrix
   CvMat newCameraMatrix
   CvSize newImageSize cvSize(0,0)
   CvRect* validPixROI NULL
+  int centerPrincipalPoint 0
 InitIntrinsicParams2D
   CvMat objectPoints
   CvMat imagePoints
diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp
index 39469ff0db..54f7e38dd8 100644
--- a/modules/python/src2/cv2.cpp
+++ b/modules/python/src2/cv2.cpp
@@ -9,6 +9,7 @@
 #include "numpy/ndarrayobject.h"
 
 #include "opencv2/core/core.hpp"
+#include "opencv2/flann/miniflann.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
 #include "opencv2/ml/ml.hpp"
@@ -17,7 +18,9 @@
 #include "opencv2/video/tracking.hpp"
 #include "opencv2/video/background_segm.hpp"
 #include "opencv2/highgui/highgui.hpp"
-#include "opencv_extra_api.hpp"
+
+using cv::flann::IndexParams;
+using cv::flann::SearchParams;
 
 static PyObject* opencv_error = 0;
 
@@ -55,6 +58,8 @@ typedef vector<Point> vector_Point;
 typedef vector<Point2f> vector_Point2f;
 typedef vector<Vec2f> vector_Vec2f;
 typedef vector<Vec3f> vector_Vec3f;
+typedef vector<Vec4f> vector_Vec4f;
+typedef vector<Vec6f> vector_Vec6f;
 typedef vector<Vec4i> vector_Vec4i;
 typedef vector<Rect> vector_Rect;
 typedef vector<KeyPoint> vector_KeyPoint;
@@ -263,7 +268,7 @@ static bool pyopencv_to(PyObject *o, Scalar& s, const char *name = "<unknown>")
         for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
             PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
             if (PyFloat_Check(item) || PyInt_Check(item)) {
-                s[i] = PyFloat_AsDouble(item);
+                s[(int)i] = PyFloat_AsDouble(item);
             } else {
                 failmsg("Scalar value for argument '%s' is not numeric", name);
                 return false;
@@ -352,6 +357,11 @@ static bool pyopencv_to(PyObject* obj, float& value, const char* name = "<unknow
     return !PyErr_Occurred();
 }
 
+static PyObject* pyopencv_from(int64 value)
+{
+    return PyFloat_FromDouble((double)value);
+}
+
 static PyObject* pyopencv_from(const string& value)
 {
     return PyString_FromString(value.empty() ? "" : value.c_str());
@@ -735,6 +745,46 @@ static inline PyObject* pyopencv_from(const CvDTreeNode* node)
     return value == ivalue ? PyInt_FromLong(ivalue) : PyFloat_FromDouble(value);
 }
 
+static bool pyopencv_to(PyObject *o, cv::flann::IndexParams& p, const char *name="<unknown>")
+{
+    bool ok = false;
+    PyObject* keys = PyObject_CallMethod(o,(char*)"keys",0);
+    PyObject* values = PyObject_CallMethod(o,(char*)"values",0);
+    
+    if( keys && values )
+    {
+        int i, n = (int)PyList_GET_SIZE(keys);
+        for( i = 0; i < n; i++ )
+        {
+            PyObject* key = PyList_GET_ITEM(keys, i);
+            PyObject* item = PyList_GET_ITEM(values, i);
+            if( !PyString_Check(key) )
+                break;
+            std::string k = PyString_AsString(key);
+            if( PyString_Check(item) )
+                p.setString(k, PyString_AsString(item));
+            else if( PyInt_Check(item) )
+                p.setInt(k, PyInt_AsLong(item));
+            else if( PyFloat_Check(item) )
+                p.setDouble(k, PyFloat_AsDouble(item));
+            else
+                break;
+        }
+        ok = i == n && !PyErr_Occurred();
+    }
+    
+    Py_XDECREF(keys);
+    Py_XDECREF(values);
+    return ok;
+}
+
+static bool pyopencv_to(PyObject *o, cvflann::flann_distance_t& dist, const char *name="<unknown>")
+{
+    int d = 0;
+    bool ok = pyopencv_to(o, d, name);
+    dist = (cvflann::flann_distance_t)d;
+    return ok;
+}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -833,6 +883,8 @@ static int to_ok(PyTypeObject *to)
   return (PyType_Ready(to) == 0);
 }
 
+#include "cv2.cv.hpp"
+
 extern "C"
 #if defined WIN32 || defined _WIN32
 __declspec(dllexport)
@@ -848,16 +900,17 @@ void initcv2()
 #include "pyopencv_generated_type_reg.h"
 #endif
 
-  PyObject* m = Py_InitModule(MODULESTR"", methods);
+  PyObject* m = Py_InitModule(MODULESTR, methods);
   PyObject* d = PyModule_GetDict(m);
 
   PyDict_SetItemString(d, "__version__", PyString_FromString("$Rev: 4557 $"));
 
   opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
   PyDict_SetItemString(d, "error", opencv_error);
+  
+  PyObject* cv_m = init_cv();
 
-  // AFAIK the only floating-point constant
-  PyDict_SetItemString(d, "CV_PI", PyFloat_FromDouble(CV_PI));
+  PyDict_SetItemString(d, "cv", cv_m);  
 
 #define PUBLISH(I) PyDict_SetItemString(d, #I, PyInt_FromLong(I))
 #define PUBLISHU(I) PyDict_SetItemString(d, #I, PyLong_FromUnsignedLong(I))
@@ -942,7 +995,6 @@ void initcv2()
 
   PUBLISH(CV_AA);
 
-
 #include "pyopencv_generated_const_reg.h"
 }
 
diff --git a/modules/python/src1/cv.cpp b/modules/python/src2/cv2.cv.hpp
similarity index 93%
rename from modules/python/src1/cv.cpp
rename to modules/python/src2/cv2.cv.hpp
index e8287733a8..cdd698f5a7 100644
--- a/modules/python/src1/cv.cpp
+++ b/modules/python/src2/cv2.cv.hpp
@@ -1,16 +1,7 @@
-#include <Python.h>
+#include "opencv2/legacy/legacy.hpp"
+#include "opencv2/legacy/compat.hpp"
 
-#include <assert.h>
-
-#include "opencv/cxcore.h"
-#include "opencv/cv.h"
-#include "opencv/cvaux.h"
-#include "opencv/cvwimage.h"
-#include "opencv/highgui.h"
-
-#define MODULESTR "cv"
-
-static PyObject *opencv_error;
+#define OLD_MODULESTR "cv2.cv"
 
 struct memtrack_t {
   PyObject_HEAD
@@ -168,21 +159,6 @@ static void translate_error_to_exception(void)
 
 /************************************************************************/
 
-static int failmsg(const char *fmt, ...)
-{
-  char str[1000];
-
-  va_list ap;
-  va_start(ap, fmt);
-  vsnprintf(str, sizeof(str), fmt, ap);
-  va_end(ap);
-
-  PyErr_SetString(PyExc_TypeError, str);
-  return 0;
-}
-
-/************************************************************************/
-
 /* These get/setters are polymorphic, used in both iplimage and cvmat */
 
 static PyObject *PyObject_FromCvScalar(CvScalar s, int type)
@@ -286,7 +262,7 @@ static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
     bps = 8;
     break;
   default:
-    return (PyObject*)failmsg("Unrecognised depth %d", i->depth);
+    return failmsg("Unrecognised depth %d", i->depth), (PyObject*)0;
   }
   int bpl = i->width * i->nChannels * bps;
   if (PyString_Check(pc->data) && bpl == i->widthStep && pc->offset == 0 && ((bpl * i->height) == what_size(pc->data))) {
@@ -300,7 +276,7 @@ static PyObject *iplimage_tostring(PyObject *self, PyObject *args)
       memcpy(s + y * bpl, i->imageData + y * i->widthStep, bpl);
     }
     PyObject *r = PyString_FromStringAndSize(s, l);
-    delete s;
+    delete[] s;
     return r;
   }
 }
@@ -355,7 +331,7 @@ static PyMappingMethods iplimage_as_map = {
 static PyTypeObject iplimage_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".iplimage",                          /*name*/
+  OLD_MODULESTR".iplimage",                          /*name*/
   sizeof(iplimage_t),                        /*basicsize*/
 };
 
@@ -441,7 +417,7 @@ static PyObject *cvmat_tostring(PyObject *self, PyObject *args)
     bps = CV_MAT_CN(m->type) * 8;
     break;
   default:
-    return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
+          return failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type)), (PyObject*)0;
   }
 
   int bpl = m->cols * bps; // bytes per line
@@ -457,7 +433,7 @@ static PyObject *cvmat_tostring(PyObject *self, PyObject *args)
       memcpy(s + y * bpl, m->data.ptr + y * m->step, bpl);
     }
     PyObject *r = PyString_FromStringAndSize(s, l);
-    delete s;
+    delete[] s;
     return r;
   }
 }
@@ -505,8 +481,8 @@ struct arrayTrack {
 static void arrayTrackDtor(void *p)
 {
   struct arrayTrack *at = (struct arrayTrack *)p;
-  delete at->s.shape;
-  delete at->s.strides;
+  delete[] at->s.shape;
+  delete[] at->s.strides;
   if (at->s.descr)
     Py_DECREF(at->s.descr);
   Py_DECREF(at->o);
@@ -665,7 +641,7 @@ static PyMappingMethods cvmat_as_map = {
 static PyTypeObject cvmat_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvmat",                      /*name*/
+  OLD_MODULESTR".cvmat",                      /*name*/
   sizeof(cvmat_t),                        /*basicsize*/
 };
 
@@ -768,15 +744,14 @@ static PyObject *cvmatnd_tostring(PyObject *self, PyObject *args)
     bps = CV_MAT_CN(m->type) * 8;
     break;
   default:
-    return (PyObject*)failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type));
+          return failmsg("Unrecognised depth %d", CV_MAT_DEPTH(m->type)), (PyObject*)0;
   }
 
-  int l = bps;
-  for (int d = 0; d < m->dims; d++) {
+  int d, l = bps;
+  for (d = 0; d < m->dims; d++) {
     l *= m->dim[d].size;
   }
   int i[CV_MAX_DIM];
-  int d;
   for (d = 0; d < m->dims; d++) {
     i[d] = 0;
   }
@@ -830,7 +805,7 @@ static PyMappingMethods cvmatnd_as_map = {
 static PyTypeObject cvmatnd_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvmatnd",                          /*name*/
+  OLD_MODULESTR".cvmatnd",                          /*name*/
   sizeof(cvmatnd_t),                        /*basicsize*/
 };
 
@@ -862,7 +837,7 @@ static void cvhistogram_dealloc(PyObject *self)
 static PyTypeObject cvhistogram_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvhistogram",                /*name*/
+  OLD_MODULESTR".cvhistogram",                /*name*/
   sizeof(cvhistogram_t),                  /*basicsize*/
 };
 
@@ -915,7 +890,7 @@ static PyObject *cvlineiterator_next(PyObject *o)
 static PyTypeObject cvlineiterator_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvlineiterator",             /*name*/
+  OLD_MODULESTR".cvlineiterator",             /*name*/
   sizeof(cvlineiterator_t),               /*basicsize*/
 };
 
@@ -958,7 +933,7 @@ static void memtrack_dealloc(PyObject *self)
 static PyTypeObject memtrack_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".memtrack",                          /*name*/
+  OLD_MODULESTR".memtrack",                          /*name*/
   sizeof(memtrack_t),                        /*basicsize*/
 };
 
@@ -1005,7 +980,7 @@ static void cvmemstorage_dealloc(PyObject *self)
 static PyTypeObject cvmemstorage_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvmemstorage",               /*name*/
+  OLD_MODULESTR".cvmemstorage",               /*name*/
   sizeof(cvmemstorage_t),                 /*basicsize*/
 };
 
@@ -1021,7 +996,7 @@ static void cvmemstorage_specials(void)
 static PyTypeObject cvfont_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvfont",                     /*name*/
+  OLD_MODULESTR".cvfont",                     /*name*/
   sizeof(cvfont_t),                       /*basicsize*/
 };
 
@@ -1034,7 +1009,7 @@ static void cvfont_specials(void) { }
 static PyTypeObject cvrng_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvrng",                     /*name*/
+  OLD_MODULESTR".cvrng",                     /*name*/
   sizeof(cvrng_t),                       /*basicsize*/
 };
 
@@ -1049,7 +1024,7 @@ static void cvrng_specials(void)
 static PyTypeObject cvcontourtree_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvcontourtree",                     /*name*/
+  OLD_MODULESTR".cvcontourtree",                     /*name*/
   sizeof(cvcontourtree_t),                       /*basicsize*/
 };
 
@@ -1063,7 +1038,7 @@ static void cvcontourtree_specials(void) { }
 static PyTypeObject cvsubdiv2dedge_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvsubdiv2dedge",                     /*name*/
+  OLD_MODULESTR".cvsubdiv2dedge",                     /*name*/
   sizeof(cvsubdiv2dedge_t),                       /*basicsize*/
 };
 
@@ -1144,7 +1119,7 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
     switch (CV_SEQ_ELTYPE(ps->a)) {
 
     case CV_SEQ_ELTYPE_POINT:
-      pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, i);
+      pt = CV_GET_SEQ_ELEM(CvPoint, ps->a, (int)i);
       return Py_BuildValue("ii", pt->x, pt->y);
 
     case CV_SEQ_ELTYPE_GENERIC:
@@ -1152,14 +1127,14 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
       case sizeof(CvQuadEdge2D):
         {
           cvsubdiv2dedge_t *r = PyObject_NEW(cvsubdiv2dedge_t, &cvsubdiv2dedge_Type);
-          r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, i);
+          r->a = (CvSubdiv2DEdge)CV_GET_SEQ_ELEM(CvQuadEdge2D, ps->a, (int)i);
           r->container = ps->container;
           Py_INCREF(r->container);
           return (PyObject*)r;
         }
       case sizeof(CvConnectedComp):
         {
-          CvConnectedComp *cc = CV_GET_SEQ_ELEM(CvConnectedComp, ps->a, i);
+          CvConnectedComp *cc = CV_GET_SEQ_ELEM(CvConnectedComp, ps->a, (int)i);
           return FROM_CvConnectedComp(*cc);
         }
       default:
@@ -1167,22 +1142,22 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
         printf("KIND %d\n", CV_SEQ_KIND(ps->a));
         assert(0);
       }
-      return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, i));
+      return PyInt_FromLong(*CV_GET_SEQ_ELEM(unsigned char, ps->a, (int)i));
 
     case CV_SEQ_ELTYPE_PTR:
     case CV_SEQ_ELTYPE_INDEX:
-      return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, i));
+      return PyInt_FromLong(*CV_GET_SEQ_ELEM(int, ps->a, (int)i));
 
     case CV_32SC4:
-      pp = CV_GET_SEQ_ELEM(pointpair, ps->a, i);
+      pp = CV_GET_SEQ_ELEM(pointpair, ps->a, (int)i);
       return Py_BuildValue("(ii),(ii)", pp->a.x, pp->a.y, pp->b.x, pp->b.y);
 
     case CV_32FC2:
-      pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, i);
+      pt2 = CV_GET_SEQ_ELEM(CvPoint2D32f, ps->a, (int)i);
       return Py_BuildValue("ff", pt2->x, pt2->y);
 
     case CV_SEQ_ELTYPE_POINT3D:
-      pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, i);
+      pt3 = CV_GET_SEQ_ELEM(CvPoint3D32f, ps->a, (int)i);
       return Py_BuildValue("fff", pt3->x, pt3->y, pt3->z);
 
     default:
@@ -1197,9 +1172,9 @@ static PyObject* cvseq_seq_getitem(PyObject *o, Py_ssize_t i)
 static PyObject* cvseq_map_getitem(PyObject *o, PyObject *item)
 {
   if (PyInt_Check(item)) {
-    long i = PyInt_AS_LONG(item);
+    int i = (int)PyInt_AS_LONG(item);
     if (i < 0)
-      i += cvseq_seq_length(o);
+      i += (int)cvseq_seq_length(o);
     return cvseq_seq_getitem(o, i);
   } else if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength, cur, i;
@@ -1246,7 +1221,7 @@ static PyMappingMethods cvseq_mapping = {
 static PyTypeObject cvseq_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvseq",                          /*name*/
+  OLD_MODULESTR".cvseq",                          /*name*/
   sizeof(cvseq_t),                        /*basicsize*/
 };
 
@@ -1294,7 +1269,7 @@ static void cvset_dealloc(PyObject *self)
 static PyTypeObject cvset_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvset",                          /*name*/
+  OLD_MODULESTR".cvset",                          /*name*/
   sizeof(cvset_t),                        /*basicsize*/
 };
 
@@ -1334,7 +1309,7 @@ static void cvset_specials(void)
 static PyTypeObject cvsubdiv2d_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                          /*size*/
-  MODULESTR".cvsubdiv2d",                     /*name*/
+  OLD_MODULESTR".cvsubdiv2d",                     /*name*/
   sizeof(cvsubdiv2d_t),                       /*basicsize*/
 };
 
@@ -1365,7 +1340,7 @@ static void cvsubdiv2d_specials(void)
 static PyTypeObject cvsubdiv2dpoint_Type = {
   PyObject_HEAD_INIT(&PyType_Type)
   0,                                      /*size*/
-  MODULESTR".cvsubdiv2dpoint",                     /*name*/
+  OLD_MODULESTR".cvsubdiv2dpoint",                     /*name*/
   sizeof(cvsubdiv2dpoint_t),                       /*basicsize*/
 };
 
@@ -1625,15 +1600,15 @@ static int convert_to_CvMat(PyObject *o, CvMat **dst, const char *name)
   Py_ssize_t buffer_len;
 
   if (!is_cvmat(o)) {
-#if !PYTHON_USE_NUMPY
-    return failmsg("Argument '%s' must be CvMat", name);
-#else
+//#if !PYTHON_USE_NUMPY
+    return failmsg("Argument '%s' must be CvMat. Use fromarray() to convert numpy arrays to CvMat", name);
+/*#else
     PyObject *asmat = fromarray(o, 0);
     if (asmat == NULL)
       return failmsg("Argument '%s' must be CvMat", name);
     // now have the array obect as a cvmat, can use regular conversion
     return convert_to_CvMat(asmat, dst, name);
-#endif
+#endif*/
   } else {
     m->a->refcount = NULL;
     if (m->data && PyString_Check(m->data)) {
@@ -1691,15 +1666,15 @@ static int convert_to_CvArr(PyObject *o, CvArr **dst, const char *name)
   } else if (is_cvmatnd(o)) {
     return convert_to_CvMatND(o, (CvMatND**)dst, name);
   } else {
-#if !PYTHON_USE_NUMPY
-    return failmsg("CvArr argument '%s' must be IplImage, CvMat or CvMatND", name);
-#else
+//#if !PYTHON_USE_NUMPY
+    return failmsg("CvArr argument '%s' must be IplImage, CvMat or CvMatND. Use fromarray() to convert numpy arrays to CvMat or cvMatND", name);
+/*#else
     PyObject *asmat = fromarray(o, 0);
     if (asmat == NULL)
       return failmsg("CvArr argument '%s' must be IplImage, CvMat, CvMatND, or support the array interface", name);
     // now have the array obect as a cvmat, can use regular conversion
     return convert_to_CvArr(asmat, dst, name);
-#endif
+#endif*/
   }
 }
 
@@ -1727,13 +1702,13 @@ static int convert_to_pts_npts_contours(PyObject *o, pts_npts_contours *dst, con
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->contours = PySequence_Fast_GET_SIZE(fi);
+  dst->contours = (int)PySequence_Fast_GET_SIZE(fi);
   dst->pts = new CvPoint*[dst->contours];
   dst->npts = new int[dst->contours];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     if (!convert_to_CvPointPTR(PySequence_Fast_GET_ITEM(fi, i), &dst->pts[i], name))
       return 0;
-    dst->npts[i] = PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
+    dst->npts[i] = (int)PySequence_Size(PySequence_Fast_GET_ITEM(fi, i)); // safe because convert_ just succeeded
   }
   Py_DECREF(fi);
   return 1;
@@ -1796,13 +1771,13 @@ static int convert_to_cvarrseq(PyObject *o, cvarrseq *dst, const char *name = "n
         return failmsg("All elements of sequence '%s' must be same size", name);
     }
     assert(size != -1);
-    CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC(size));
+    CvMat *mt = cvCreateMat((int)PySequence_Fast_GET_SIZE(fi), 1, CV_32SC((int)size));
     dst->freemat = true; // dealloc this mat when done
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *e = PySequence_Fast_GET_ITEM(fi, i);
       PyObject *fe = PySequence_Fast(e, name);
       assert(fe != NULL);
-      int *pdst = (int*)cvPtr2D(mt, i, 0);
+      int *pdst = (int*)cvPtr2D(mt, (int)i, 0);
       for (Py_ssize_t j = 0; j < size; j++) {
         PyObject *num = PySequence_Fast_GET_ITEM(fe, j);
         if (!PyNumber_Check(num)) {
@@ -1830,7 +1805,7 @@ static int convert_to_cvarr_count(PyObject *o, cvarr_count *dst, const char *nam
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->cvarr = new CvArr*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     if (!convert_to_CvArr(PySequence_Fast_GET_ITEM(fi, i), &dst->cvarr[i], name))
@@ -1851,7 +1826,7 @@ static int convert_to_intpair(PyObject *o, intpair *dst, const char *name = "no_
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->pairs = new int[2 * dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1889,7 +1864,7 @@ static int convert_to_floats(PyObject *o, floats *dst, const char *name = "no_na
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL)
       return 0;
-    dst->count = PySequence_Fast_GET_SIZE(fi);
+    dst->count = (int)PySequence_Fast_GET_SIZE(fi);
     dst->f = new float[dst->count];
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1921,7 +1896,7 @@ static int convert_to_CvPoints(PyObject *o, CvPoints *dst, const char *name = "n
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1940,7 +1915,7 @@ static int convert_to_CvPoint3D32fs(PyObject *o, CvPoint3D32fs *dst, const char
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint3D32f[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1959,7 +1934,7 @@ static int convert_to_CvPoint2D32fs(PyObject *o, CvPoint2D32fs *dst, const char
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->p = new CvPoint2D32f[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1978,7 +1953,7 @@ static int convert_to_ints(PyObject *o, ints *dst, const char *name = "no_name")
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->i = new int[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -1997,7 +1972,7 @@ static int convert_to_ints0(PyObject *o, ints0 *dst, const char *name = "no_name
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->i = new int[dst->count + 1];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -2021,9 +1996,9 @@ static int convert_to_dim(PyObject *item, int i, dims *dst, CvArr *cva, const ch
   if (PySlice_Check(item)) {
     Py_ssize_t start, stop, step, slicelength;
     PySlice_GetIndicesEx((PySliceObject*)item, cvGetDimSize(cva, i), &start, &stop, &step, &slicelength);
-    dst->i[i] = start;
-    dst->step[i] = step;
-    dst->length[i] = slicelength;
+    dst->i[i] = (int)start;
+    dst->step[i] = (int)step;
+    dst->length[i] = (int)slicelength;
   } else {
     int index = PyInt_AsLong(item);
     if (0 <= index)
@@ -2047,13 +2022,13 @@ static int convert_to_dims(PyObject *o, dims *dst, CvArr *cva, const char *name
       PyErr_SetString(PyExc_TypeError, "Expected tuple for index");
       return 0;
     }
-    dst->count = PySequence_Fast_GET_SIZE(fi);
+    dst->count = (int)PySequence_Fast_GET_SIZE(fi);
     for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
       if (i >= cvGetDims(cva)) {
         return failmsg("Access specifies %d dimensions, but array only has %d", PySequence_Fast_GET_SIZE(fi), cvGetDims(cva));
       }
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
-      if (!convert_to_dim(item, i, dst, cva, name))
+      if (!convert_to_dim(item, (int)i, dst, cva, name))
         return 0;
     }
     Py_DECREF(fi);
@@ -2070,7 +2045,7 @@ static int convert_to_IplImages(PyObject *o, IplImages *dst, const char *name =
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->ims = new IplImage*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -2090,7 +2065,7 @@ static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_na
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  dst->count = PySequence_Fast_GET_SIZE(fi);
+  dst->count = (int)PySequence_Fast_GET_SIZE(fi);
   dst->ims = new CvArr*[dst->count];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -2106,7 +2081,7 @@ static int convert_to_CvArrs(PyObject *o, CvArrs *dst, const char *name = "no_na
   PyObject *fi = PySequence_Fast(o, name);
   if (fi == NULL)
     return 0;
-  Py_ssize_t sz = PySequence_Fast_GET_SIZE(fi);
+  Py_ssize_t sz = (int)PySequence_Fast_GET_SIZE(fi);
   float **r = new float*[sz];
   for (Py_ssize_t i = 0; i < PySequence_Fast_GET_SIZE(fi); i++) {
     PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -2863,20 +2838,20 @@ static PyObject *fromarray(PyObject *o, int allowND)
     cvmat_t *m = PyObject_NEW(cvmat_t, &cvmat_Type);
     if (pai->nd == 2) {
       if (pai->strides[1] != pai->itemsize) {
-        return (PyObject*)failmsg("cv.fromarray array can only accept arrays with contiguous data");
+        return failmsg("cv.fromarray array can only accept arrays with contiguous data"), (PyObject*)0;
       }
-      ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type));
-      m->a->step = pai->strides[0];
+      ERRWRAP(m->a = cvCreateMatHeader((int)pai->shape[0], (int)pai->shape[1], type));
+      m->a->step = (int)pai->strides[0];
     } else if (pai->nd == 3) {
       if (pai->shape[2] > CV_CN_MAX) {
         Py_DECREF(ao);  
-        return (PyObject*)failmsg("cv.fromarray too many channels, see allowND argument");
+        return failmsg("cv.fromarray too many channels, see allowND argument"), (PyObject*)0;
       }
-      ERRWRAP(m->a = cvCreateMatHeader(pai->shape[0], pai->shape[1], type + ((pai->shape[2] - 1) << CV_CN_SHIFT)));
-      m->a->step = pai->strides[0];
+      ERRWRAP(m->a = cvCreateMatHeader((int)pai->shape[0], (int)pai->shape[1], type + ((int)(pai->shape[2] - 1) << CV_CN_SHIFT)));
+      m->a->step = (int)pai->strides[0];
     } else {
       Py_DECREF(ao);   
-      return (PyObject*)failmsg("cv.fromarray array can be 2D or 3D only, see allowND argument");
+      return failmsg("cv.fromarray array can be 2D or 3D only, see allowND argument"), (PyObject*)0;
     }
     m->a->data.ptr = (uchar*)pai->data;
     //retval = pythonize_foreign_CvMat(m);
@@ -2887,7 +2862,7 @@ static PyObject *fromarray(PyObject *o, int allowND)
     int dims[CV_MAX_DIM];
     int i;
     for (i = 0; i < pai->nd; i++)
-      dims[i] = pai->shape[i];
+      dims[i] = (int)pai->shape[i];
     cvmatnd_t *m = PyObject_NEW(cvmatnd_t, &cvmatnd_Type);
     ERRWRAP(m->a = cvCreateMatNDHeader(pai->nd, dims, type));
     m->a->data.ptr = (uchar*)pai->data;
@@ -2914,7 +2889,7 @@ public:
     PyObject *fi = PySequence_Fast(o, name);
     if (fi == NULL)
       return 0;
-    len = PySequence_Fast_GET_SIZE(fi);
+    len = (int)PySequence_Fast_GET_SIZE(fi);
     rr = new float*[len];
     for (Py_ssize_t i = 0; i < len; i++) {
       PyObject *item = PySequence_Fast_GET_ITEM(fi, i);
@@ -2929,7 +2904,7 @@ public:
   ~ranges() {
     for (Py_ssize_t i = 0; i < len; i++)
       delete rr[i];
-   delete rr;
+    delete[] rr;
   }
 };
 
@@ -3043,18 +3018,18 @@ static PyObject *cvarr_GetItem(PyObject *o, PyObject *key)
     // negative steps are illegal for OpenCV
     for (int i = 0; i < dd.count; i++) {
       if (dd.step[i] < 0)
-        return (PyObject*)failmsg("Negative step is illegal");
+        return failmsg("Negative step is illegal"), (PyObject*)0;
     }
 
     // zero length illegal for OpenCV
     for (int i = 0; i < dd.count; i++) {
       if (dd.length[i] == 0)
-        return (PyObject*)failmsg("Zero sized dimension is illegal");
+        return failmsg("Zero sized dimension is illegal"), (PyObject*)0;
     }
 
     // column step can only be 0 or 1
     if ((dd.step[dd.count-1] != 0) && (dd.step[dd.count-1] != 1))
-        return (PyObject*)failmsg("Column step is illegal");
+        return failmsg("Column step is illegal"), (PyObject*)0;
 
     if (is_cvmat(o) || is_iplimage(o)) {
       cvmat_t *sub = PyObject_NEW(cvmat_t, &cvmat_Type);
@@ -3367,75 +3342,6 @@ static PyObject *pycvReshapeMatND(PyObject *self, PyObject *args)
   return shareDataND(o, cva, pn);
 }
 
-static void OnMouse(int event, int x, int y, int flags, void* param)
-{
-  PyGILState_STATE gstate;
-  gstate = PyGILState_Ensure();
-
-  PyObject *o = (PyObject*)param;
-  PyObject *args = Py_BuildValue("iiiiO", event, x, y, flags, PyTuple_GetItem(o, 1));
-
-  PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
-  if (r == NULL)
-    PyErr_Print();
-  else
-    Py_DECREF(r);
-  Py_DECREF(args);
-  PyGILState_Release(gstate);
-}
-
-static PyObject *pycvSetMouseCallback(PyObject *self, PyObject *args, PyObject *kw)
-{
-  const char *keywords[] = { "window_name", "on_mouse", "param", NULL };
-  char* name;
-  PyObject *on_mouse;
-  PyObject *param = NULL;
-
-  if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|O", (char**)keywords, &name, &on_mouse, &param))
-    return NULL;
-  if (!PyCallable_Check(on_mouse)) {
-    PyErr_SetString(PyExc_TypeError, "on_mouse must be callable");
-    return NULL;
-  }
-  if (param == NULL) {
-    param = Py_None;
-  }
-  ERRWRAP(cvSetMouseCallback(name, OnMouse, Py_BuildValue("OO", on_mouse, param)));
-  Py_RETURN_NONE;
-}
-
-void OnChange(int pos, void *param)
-{
-  PyGILState_STATE gstate;
-  gstate = PyGILState_Ensure();
-
-  PyObject *o = (PyObject*)param;
-  PyObject *args = Py_BuildValue("(i)", pos);
-  PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL);
-  if (r == NULL)
-    PyErr_Print();
-  Py_DECREF(args);
-  PyGILState_Release(gstate);
-}
-
-static PyObject *pycvCreateTrackbar(PyObject *self, PyObject *args)
-{
-  PyObject *on_change;
-  char* trackbar_name;
-  char* window_name;
-  int *value = new int;
-  int count;
-
-  if (!PyArg_ParseTuple(args, "ssiiO", &trackbar_name, &window_name, value, &count, &on_change))
-    return NULL;
-  if (!PyCallable_Check(on_change)) {
-    PyErr_SetString(PyExc_TypeError, "on_change must be callable");
-    return NULL;
-  }
-  ERRWRAP(cvCreateTrackbar2(trackbar_name, window_name, value, count, OnChange, Py_BuildValue("OO", on_change, Py_None)));
-  Py_RETURN_NONE;
-}
-
 static PyObject *pycvFindContours(PyObject *self, PyObject *args, PyObject *kw)
 {
   CvArr* image;
@@ -3570,7 +3476,7 @@ static PyObject *pycvSubdiv2DLocate(PyObject *self, PyObject *args)
     Py_INCREF(Py_None);
     break;
   default:
-    return (PyObject*)failmsg("Unexpected loc from cvSubdiv2DLocate");
+    return failmsg("Unexpected loc from cvSubdiv2DLocate"), (PyObject*)0;
   }
   return Py_BuildValue("iO", (int)loc, r);
 }
@@ -3787,7 +3693,7 @@ static PyObject *shareData(PyObject *donor, CvArr *pdonor, CvMat *precipient)
     arr_data = ((iplimage_t*)donor)->data;
     ((cvmat_t*)recipient)->offset += ((iplimage_t*)donor)->offset;
   } else {
-    return (PyObject*)failmsg("Argument 'mat' must be either IplImage or CvMat");
+    return failmsg("Argument 'mat' must be either IplImage or CvMat"), (PyObject*)0;
   }
   ((cvmat_t*)recipient)->data = arr_data;
   Py_INCREF(arr_data);
@@ -3964,17 +3870,12 @@ static double cppKMeans(const CvArr* _samples, int cluster_count, CvArr* _labels
 
 #include "generated0.i"
 
-static PyMethodDef methods[] = {
+static PyMethodDef old_methods[] = {
 
 #if PYTHON_USE_NUMPY
     {"fromarray", (PyCFunction)pycvfromarray, METH_KEYWORDS, "fromarray(array) -> cvmatnd"},
 #endif
 
-  //{"CalcOpticalFlowFarneback", (PyCFunction)pycvCalcOpticalFlowFarneback, METH_KEYWORDS, "CalcOpticalFlowFarneback(prev, next, flow, pyr_scale=0.5, levels=3, win_size=15, iterations=3, poly_n=7, poly_sigma=1.5, flags=0) -> None"},
-  //{"_HOGComputeDescriptors", (PyCFunction)pycvHOGComputeDescriptors, METH_KEYWORDS, "_HOGComputeDescriptors(image, win_stride=block_stride, locations=None, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_descriptors"},
-  //{"_HOGDetect", (PyCFunction)pycvHOGDetect, METH_KEYWORDS, "_HOGDetect(image, svm_classifier, win_stride=block_stride, locations=None, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_points"},
-  //{"_HOGDetectMultiScale", (PyCFunction)pycvHOGDetectMultiScale, METH_KEYWORDS, "_HOGDetectMultiScale(image, svm_classifier, win_stride=block_stride, scale=1.05, group_threshold=2, padding=(0,0), win_size=(64,128), block_size=(16,16), block_stride=(8,8), cell_size=(8,8), nbins=9, gammaCorrection=true) -> list_of_points"},
-
   {"FindDataMatrix", pyfinddatamatrix, METH_VARARGS},
   {"temp_test", temp_test, METH_VARARGS},
 
@@ -3986,33 +3887,13 @@ static PyMethodDef methods[] = {
 /************************************************************************/
 /* Module init */
 
-static int to_ok(PyTypeObject *to)
+PyObject* init_cv()
 {
-  to->tp_alloc = PyType_GenericAlloc;
-  to->tp_new = PyType_GenericNew;
-  to->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
-  return (PyType_Ready(to) == 0);
-}
-
-#define MKTYPE(NAME)  NAME##_specials(); if (!to_ok(&NAME##_Type)) return
-
-using namespace cv;
-
-extern "C"
-#if defined WIN32 || defined _WIN32
-__declspec(dllexport)
-#endif
-
-void initcv()
-{
-#if PYTHON_USE_NUMPY
-    import_array();
-#endif
-    
   PyObject *m, *d;
-
   cvSetErrMode(CV_ErrModeParent);
 
+  #define MKTYPE(NAME)  NAME##_specials(); to_ok(&NAME##_Type)
+
   MKTYPE(cvcontourtree);
   MKTYPE(cvfont);
   MKTYPE(cvhistogram);
@@ -4031,12 +3912,12 @@ void initcv()
 
 #include "generated4.i"
 
-  m = Py_InitModule(MODULESTR"", methods);
+  #undef MKTYPE
+
+  m = Py_InitModule(OLD_MODULESTR, old_methods);
   d = PyModule_GetDict(m);
 
   PyDict_SetItemString(d, "__version__", PyString_FromString("$Rev: 4557 $"));
-
-  opencv_error = PyErr_NewException((char*)MODULESTR".error", NULL, NULL);
   PyDict_SetItemString(d, "error", opencv_error);
 
   // Couple of warnings about strict aliasing here.  Not clear how to fix.
@@ -4127,7 +4008,13 @@ void initcv()
   PUBLISH(GC_INIT_WITH_RECT);
   PUBLISH(GC_INIT_WITH_MASK);
   PUBLISH(GC_EVAL);
-
+  
 #include "generated2.i"
+
+#undef PUBLISH
+#undef PUBLISHU
+#undef PUBLISH2    
+    
+  return m;
 }
 
diff --git a/modules/python/src1/defs b/modules/python/src2/defs
similarity index 100%
rename from modules/python/src1/defs
rename to modules/python/src2/defs
diff --git a/modules/python/src1/gen.py b/modules/python/src2/gen.py
similarity index 100%
rename from modules/python/src1/gen.py
rename to modules/python/src2/gen.py
diff --git a/modules/python/src2/gen2.py b/modules/python/src2/gen2.py
index 65be794212..a236ac8e5d 100644
--- a/modules/python/src2/gen2.py
+++ b/modules/python/src2/gen2.py
@@ -164,6 +164,9 @@ simple_argtype_mapping = {
     "c_string": ("char*", "s", '(char*)""')
 }
 
+def normalize_class_name(name):
+    return re.sub(r"^cv\.", "", name).replace(".", "_")
+
 class ClassProp(object):
     def __init__(self, decl):
         self.tp = decl[0].replace("*", "_ptr")
@@ -175,7 +178,7 @@ class ClassProp(object):
 class ClassInfo(object):
     def __init__(self, name, decl=None):
         self.cname = name.replace(".", "::")
-        self.name = self.wname = re.sub(r"^cv\.", "", name)
+        self.name = self.wname = normalize_class_name(name)
         self.ismap = False
         self.issimple = False
         self.methods = {}
@@ -275,10 +278,12 @@ class ArgInfo(object):
         self.arraycvt = None
         self.inputarg = True
         self.outputarg = False
+        self.returnarg = False
         for m in arg_tuple[3]:
             if m == "/O":
                 self.inputarg = False
                 self.outputarg = True
+                self.returnarg = True
             elif m == "/IO":
                 self.inputarg = True
                 self.outputarg = True
@@ -300,8 +305,12 @@ class FuncVariant(object):
         self.classname = classname
         self.name = self.wname = name
         self.isconstructor = isconstructor
-        if self.isconstructor and self.wname.startswith("Cv"):
-            self.wname = self.wname[2:]
+        if self.isconstructor:
+            if self.wname.startswith("Cv"):
+                self.wname = self.wname[2:]
+            else:
+                self.wname = self.classname
+            
         self.rettype = decl[1]
         if self.rettype == "void":
             self.rettype = ""
@@ -346,9 +355,9 @@ class FuncVariant(object):
             argno += 1
             if a.name in self.array_counters:
                 continue
-            if a.outputarg:
+            if a.returnarg:
                 outlist.append((a.name, argno))
-            if not a.inputarg:
+            if not a.inputarg or a.returnarg:
                 if a.isbig():
                     outarr_list.append((a.name, argno))
                 continue
@@ -446,7 +455,7 @@ class FuncInfo(object):
             s = self.variants[idx].py_docstring
             p1 = s.find("(")
             p2 = s.rfind(")")
-            docstring_list = [s[:p1+1] + "[" + s[p1+2:p2] + "]" + s[p2:]]
+            docstring_list = [s[:p1+1] + "[" + s[p1+1:p2] + "]" + s[p2:]]
             
         return Template('    {"$py_funcname", (PyCFunction)$wrap_funcname, METH_KEYWORDS, "$py_docstring"},\n'
                         ).substitute(py_funcname = self.variants[0].wname, wrap_funcname=self.get_wrapper_name(),
@@ -557,7 +566,7 @@ class FuncInfo(object):
                 amapping = simple_argtype_mapping.get(tp, (tp, "O", "0"))
                 all_cargs.append(amapping)
 
-            if v.args:
+            if v.args and v.py_arglist:
                 # form the format spec for PyArg_ParseTupleAndKeywords
                 fmtspec = "".join([all_cargs[argno][0][1] for aname, argno in v.py_arglist])
                 if v.py_noptargs > 0:
@@ -643,15 +652,19 @@ class PythonWrapperGenerator(object):
         self.consts[constinfo.name] = constinfo
 
     def add_func(self, decl):
-        classname = ""
+        classname = bareclassname = ""
         name = decl[0]
         dpos = name.rfind(".")
         if dpos >= 0 and name[:dpos] != "cv":
-            classname = re.sub(r"^cv\.", "", name[:dpos])
+            classname = bareclassname = re.sub(r"^cv\.", "", name[:dpos])
             name = name[dpos+1:]
+            dpos = classname.rfind(".")
+            if dpos >= 0:
+                bareclassname = classname[dpos+1:]
+                classname = classname.replace(".", "_")
         cname = name
         name = re.sub(r"^cv\.", "", name)
-        isconstructor = cname == classname
+        isconstructor = cname == bareclassname
         cname = cname.replace(".", "::")
         isclassmethod = False
         customname = False
diff --git a/modules/python/src2/hdr_parser.py b/modules/python/src2/hdr_parser.py
index c0bfdaf007..4fa6cf99d6 100755
--- a/modules/python/src2/hdr_parser.py
+++ b/modules/python/src2/hdr_parser.py
@@ -3,6 +3,7 @@ import os, sys, re, string
 # the list only for debugging. The real list, used in the real OpenCV build, is specified in CMakeLists.txt
 opencv_hdr_list = [
 "../../core/include/opencv2/core/core.hpp",
+"../../flann/include/opencv2/flann/miniflann.hpp",
 "../../ml/include/opencv2/ml/ml.hpp",
 "../../imgproc/include/opencv2/imgproc/imgproc.hpp",
 "../../calib3d/include/opencv2/calib3d/calib3d.hpp",
@@ -253,7 +254,7 @@ class CppHeaderParser(object):
             fnpos = 0
         fname = fname[fnpos:].strip()
         rettype = fdecl[:fnpos].strip()
-        
+
         if rettype.endswith("operator"):
             fname = ("operator " + fname).strip()
             rettype = rettype[:rettype.rfind("operator")].strip()
@@ -265,16 +266,16 @@ class CppHeaderParser(object):
                 else:
                     fname = rettype + fname
                     rettype = ""
-        
+
         apos = fdecl.find("(")
         if fname.endswith("operator"):
             fname += "()"
             apos = fdecl.find("(", apos+1)
-            
+
         fname = "cv." + fname.replace("::", ".")
         decl = [fname, rettype, [], []]
         args0str = fdecl[apos+1:fdecl.rfind(")")].strip()
-        
+
         if args0str != "":
             args0 = args0str.split(",")
 
@@ -287,17 +288,19 @@ class CppHeaderParser(object):
                 if balance_paren == 0 and balance_angle == 0:
                     args.append(narg.strip())
                     narg = ""
-        
+
             for arg in args:
                 dfpos = arg.find("=")
                 defval = ""
                 if dfpos >= 0:
                     defval = arg[dfpos+1:].strip()
                     arg = arg[:dfpos].strip()
-                pos = arg.rfind(" ")
+                pos = len(arg)-1
+                while pos >= 0 and (arg[pos] == "_" or arg[pos].isalpha() or arg[pos].isdigit()):
+                    pos -= 1
                 if pos >= 0:
                     aname = arg[pos+1:].strip()
-                    atype = arg[:pos].strip()
+                    atype = arg[:pos+1].strip()
                     if aname.endswith("&") or aname.endswith("*") or (aname in ["int", "string", "Mat"]):
                         atype = (atype + " " + aname).strip()
                         aname = "param"
@@ -305,7 +308,7 @@ class CppHeaderParser(object):
                     atype = arg
                     aname = "param"
                 decl[3].append([atype, aname, defval, []])
-        
+
         return decl
 
     def parse_func_decl(self, decl_str):
@@ -324,11 +327,11 @@ class CppHeaderParser(object):
             if not (("CV_EXPORTS_AS" in decl_str) or ("CV_EXPORTS_W" in decl_str) or \
                 ("CV_WRAP" in decl_str) or ("CV_WRAP_AS" in decl_str)):
                 return []
-        
-        # ignore old API in the documentation check (for now)        
+
+        # ignore old API in the documentation check (for now)
         if "CVAPI(" in decl_str:
-            return [] 
-                
+            return []
+
         top = self.block_stack[-1]
         func_modlist = []
 
@@ -452,13 +455,19 @@ class CppHeaderParser(object):
                         a = a[:eqpos].strip()
                     arg_type, arg_name, modlist, argno = self.parse_arg(a, argno)
                     if self.wrap_mode:
-                        if arg_type == "InputArray" or arg_type == "InputOutputArray":
+                        if arg_type == "InputArray":
                             arg_type = "Mat"
+                        elif arg_type == "InputOutputArray":
+                            arg_type = "Mat"
+                            modlist.append("/IO")
                         elif arg_type == "OutputArray":
                             arg_type = "Mat"
                             modlist.append("/O")
-                        elif arg_type == "InputArrayOfArrays" or arg_type == "InputOutputArrayOfArrays":
+                        elif arg_type == "InputArrayOfArrays":
                             arg_type = "vector_Mat"
+                        elif arg_type == "InputOutputArrayOfArrays":
+                            arg_type = "vector_Mat"
+                            modlist.append("/IO")
                         elif arg_type == "OutputArrayOfArrays":
                             arg_type = "vector_Mat"
                             modlist.append("/O")
diff --git a/modules/python/src2/opencv_extra_api.hpp b/modules/python/src2/opencv_extra_api.hpp
deleted file mode 100644
index eee9e5a75f..0000000000
--- a/modules/python/src2/opencv_extra_api.hpp
+++ /dev/null
@@ -1,295 +0,0 @@
-#ifndef _OPENCV_API_EXTRA_HPP_
-#define _OPENCV_API_EXTRA_HPP_
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/calib3d/calib3d.hpp"
-
-namespace cv
-{
-
-template<typename _Tp>
-static inline void mv2vv(const vector<Mat>& src, vector<vector<_Tp> >& dst)
-{
-    size_t i, n = src.size();
-    dst.resize(src.size());
-    for( i = 0; i < n; i++ )
-        src[i].copyTo(dst[i]);
-}
-
-///////////////////////////// core /////////////////////////////
-
-CV_WRAP_AS(getTickCount) static inline double getTickCount_()
-{
-    return (double)getTickCount();
-}
-
-CV_WRAP_AS(getCPUTickCount) static inline double getCPUTickCount_()
-{
-    return (double)getCPUTickCount();
-}
-
-CV_WRAP void randShuffle(const Mat& src, CV_OUT Mat& dst, double iterFactor=1.)
-{
-    src.copyTo(dst);
-    randShuffle(dst, iterFactor, 0);
-}
-
-CV_WRAP static inline void SVDecomp(const Mat& src, CV_OUT Mat& w, CV_OUT Mat& u, CV_OUT Mat& vt, int flags=0 )
-{
-    SVD::compute(src, w, u, vt, flags);
-}
-
-CV_WRAP static inline void SVBackSubst( const Mat& w, const Mat& u, const Mat& vt,
-                                        const Mat& rhs, CV_OUT Mat& dst )
-{
-    SVD::backSubst(w, u, vt, rhs, dst);
-}
-
-CV_WRAP static inline void mixChannels(const vector<Mat>& src, vector<Mat>& dst,
-                                       const vector<int>& fromTo)
-{
-    if(fromTo.empty())
-        return;
-    CV_Assert(fromTo.size()%2 == 0);
-    mixChannels(&src[0], (int)src.size(), &dst[0], (int)dst.size(), &fromTo[0], (int)(fromTo.size()/2));
-}
-
-CV_WRAP static inline bool eigen(const Mat& src, bool computeEigenvectors,
-                                 CV_OUT Mat& eigenvalues, CV_OUT Mat& eigenvectors,
-                                 int lowindex=-1, int highindex=-1)
-{
-    return computeEigenvectors ? eigen(src, eigenvalues, eigenvectors, lowindex, highindex) :
-                                eigen(src, eigenvalues, lowindex, highindex);
-}
-
-CV_WRAP static inline void fillConvexPoly(Mat& img, const Mat& points,
-                               const Scalar& color, int lineType=8,
-                               int shift=0)
-{
-    CV_Assert(points.checkVector(2, CV_32S) >= 0);
-    fillConvexPoly(img, (const Point*)points.data, points.rows*points.cols*points.channels()/2, color, lineType, shift);
-}
-
-CV_WRAP static inline void fillPoly(Mat& img, const vector<Mat>& pts,
-                                   const Scalar& color, int lineType=8, int shift=0,
-                                   Point offset=Point() )
-{
-    if( pts.empty() )
-        return;
-    AutoBuffer<Point*> _ptsptr(pts.size());
-    AutoBuffer<int> _npts(pts.size());
-    Point** ptsptr = _ptsptr;
-    int* npts = _npts;
-    
-    for( size_t i = 0; i < pts.size(); i++ )
-    {
-        const Mat& p = pts[i];
-        CV_Assert(p.checkVector(2, CV_32S) >= 0);
-        ptsptr[i] = (Point*)p.data;
-        npts[i] = p.rows*p.cols*p.channels()/2;
-    }
-    fillPoly(img, (const Point**)ptsptr, npts, (int)pts.size(), color, lineType, shift, offset);
-}
-
-CV_WRAP static inline void polylines(Mat& img, const vector<Mat>& pts,
-                          bool isClosed, const Scalar& color,
-                          int thickness=1, int lineType=8, int shift=0 )
-{
-    if( pts.empty() )
-        return;
-    AutoBuffer<Point*> _ptsptr(pts.size());
-    AutoBuffer<int> _npts(pts.size());
-    Point** ptsptr = _ptsptr;
-    int* npts = _npts;
-    
-    for( size_t i = 0; i < pts.size(); i++ )
-    {
-        const Mat& p = pts[i];
-        CV_Assert(p.checkVector(2, CV_32S) >= 0);
-        ptsptr[i] = (Point*)p.data;
-        npts[i] = p.rows*p.cols*p.channels()/2;
-    }
-    polylines(img, (const Point**)ptsptr, npts, (int)pts.size(), isClosed, color, thickness, lineType, shift);
-}
-
-CV_WRAP static inline void PCACompute(const Mat& data, CV_OUT Mat& mean,
-                                      CV_OUT Mat& eigenvectors, int maxComponents=0)
-{
-    PCA pca;
-    pca.mean = mean;
-    pca.eigenvectors = eigenvectors;
-    pca(data, Mat(), 0, maxComponents);
-    pca.mean.copyTo(mean);
-    pca.eigenvectors.copyTo(eigenvectors);
-}
-    
-CV_WRAP static inline void PCAProject(const Mat& data, const Mat& mean,
-                                      const Mat& eigenvectors, CV_OUT Mat& result)
-{
-    PCA pca;
-    pca.mean = mean;
-    pca.eigenvectors = eigenvectors;
-    pca.project(data, result);
-}
-
-CV_WRAP static inline void PCABackProject(const Mat& data, const Mat& mean,
-                                          const Mat& eigenvectors, CV_OUT Mat& result)
-{
-    PCA pca;
-    pca.mean = mean;
-    pca.eigenvectors = eigenvectors;
-    pca.backProject(data, result);
-}    
-
-/////////////////////////// imgproc /////////////////////////////////
-
-CV_WRAP static inline void HuMoments(const Moments& m, CV_OUT vector<double>& hu)
-{
-    hu.resize(7);
-    HuMoments(m, &hu[0]);
-}
-
-CV_WRAP static inline Mat getPerspectiveTransform(const vector<Point2f>& src, const vector<Point2f>& dst)
-{
-    CV_Assert(src.size() == 4 && dst.size() == 4);
-    return getPerspectiveTransform(&src[0], &dst[0]);
-}
-
-CV_WRAP static inline Mat getAffineTransform(const vector<Point2f>& src, const vector<Point2f>& dst)
-{
-    CV_Assert(src.size() == 3 && dst.size() == 3);
-    return getAffineTransform(&src[0], &dst[0]);
-}
-
-CV_WRAP static inline void calcHist( const vector<Mat>& images, const vector<int>& channels,
-                                     const Mat& mask, CV_OUT Mat& hist,
-                                     const vector<int>& histSize,
-                                     const vector<float>& ranges,
-                                     bool accumulate=false)
-{
-    int i, dims = (int)histSize.size(), rsz = (int)ranges.size(), csz = (int)channels.size();
-    CV_Assert(images.size() > 0 && dims > 0);
-    CV_Assert(rsz == dims*2 || (rsz == 0 && images[0].depth() == CV_8U));
-    CV_Assert(csz == 0 || csz == dims);
-    float* _ranges[CV_MAX_DIM];
-    if( rsz > 0 )
-    {
-        for( i = 0; i < rsz/2; i++ )
-            _ranges[i] = (float*)&ranges[i*2];
-    }
-    calcHist(&images[0], (int)images.size(), csz ? &channels[0] : 0,
-            mask, hist, dims, &histSize[0], rsz ? (const float**)_ranges : 0,
-            true, accumulate);
-}
-
-                                     
-CV_WRAP void calcBackProject( const vector<Mat>& images, const vector<int>& channels,
-                              const Mat& hist, CV_OUT Mat& dst,
-                              const vector<float>& ranges,
-                              double scale=1 )
-{
-    int i, dims = hist.dims, rsz = (int)ranges.size(), csz = (int)channels.size();
-    CV_Assert(images.size() > 0);
-    CV_Assert(rsz == dims*2 || (rsz == 0 && images[0].depth() == CV_8U));
-    CV_Assert(csz == 0 || csz == dims);
-    float* _ranges[CV_MAX_DIM];
-    if( rsz > 0 )
-    {
-        for( i = 0; i < rsz/2; i++ )
-            _ranges[i] = (float*)&ranges[i*2];
-    }
-    calcBackProject(&images[0], (int)images.size(), csz ? &channels[0] : 0,
-        hist, dst, rsz ? (const float**)_ranges : 0, scale, true);
-}
-
-
-/////////////////////////////// calib3d ///////////////////////////////////////////
-
-//! finds circles' grid pattern of the specified size in the image
-CV_WRAP static inline void findCirclesGridDefault( InputArray image, Size patternSize,
-                                                   OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID )
-{
-    findCirclesGrid(image, patternSize, centers, flags);
-}
-
-
-/*
-//! initializes camera matrix from a few 3D points and the corresponding projections.
-CV_WRAP static inline Mat initCameraMatrix2D( const vector<Mat>& objectPoints,
-                                   const vector<Mat>& imagePoints,
-                                   Size imageSize, double aspectRatio=1. )
-{
-    vector<vector<Point3f> > _objectPoints;
-    vector<vector<Point2f> > _imagePoints;
-    mv2vv(objectPoints, _objectPoints);
-    mv2vv(imagePoints, _imagePoints);
-    return initCameraMatrix2D(_objectPoints, _imagePoints, imageSize, aspectRatio);
-}
-
-
-CV_WRAP static inline double calibrateCamera( const vector<Mat>& objectPoints,
-                                  const vector<Mat>& imagePoints,
-                                  Size imageSize,
-                                  CV_IN_OUT Mat& cameraMatrix,
-                                  CV_IN_OUT Mat& distCoeffs,
-                                  vector<Mat>& rvecs, vector<Mat>& tvecs,
-                                  int flags=0 )
-{
-    vector<vector<Point3f> > _objectPoints;
-    vector<vector<Point2f> > _imagePoints;
-    mv2vv(objectPoints, _objectPoints);
-    mv2vv(imagePoints, _imagePoints);
-    return calibrateCamera(_objectPoints, _imagePoints, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags);
-}
-
-
-CV_WRAP static inline double stereoCalibrate( const vector<Mat>& objectPoints,
-                                  const vector<Mat>& imagePoints1,
-                                  const vector<Mat>& imagePoints2,
-                                  CV_IN_OUT Mat& cameraMatrix1, CV_IN_OUT Mat& distCoeffs1,
-                                  CV_IN_OUT Mat& cameraMatrix2, CV_IN_OUT Mat& distCoeffs2,
-                                  Size imageSize, CV_OUT Mat& R, CV_OUT Mat& T,
-                                  CV_OUT Mat& E, CV_OUT Mat& F,
-                                  TermCriteria criteria = TermCriteria(TermCriteria::COUNT+
-                                                                       TermCriteria::EPS, 30, 1e-6),
-                                  int flags=CALIB_FIX_INTRINSIC )
-{
-    vector<vector<Point3f> > _objectPoints;
-    vector<vector<Point2f> > _imagePoints1;
-    vector<vector<Point2f> > _imagePoints2;
-    mv2vv(objectPoints, _objectPoints);
-    mv2vv(imagePoints1, _imagePoints1);
-    mv2vv(imagePoints2, _imagePoints2);
-    return stereoCalibrate(_objectPoints, _imagePoints1, _imagePoints2, cameraMatrix1, distCoeffs1,
-                            cameraMatrix2, distCoeffs2, imageSize, R, T, E, F, criteria, flags);
-}
-
-CV_WRAP static inline float rectify3Collinear( const Mat& cameraMatrix1, const Mat& distCoeffs1,
-                     const Mat& cameraMatrix2, const Mat& distCoeffs2,
-                     const Mat& cameraMatrix3, const Mat& distCoeffs3,
-                     const vector<Mat>& imgpt1, const vector<Mat>& imgpt3,
-                     Size imageSize, const Mat& R12, const Mat& T12,
-                     const Mat& R13, const Mat& T13,
-                     CV_OUT Mat& R1, CV_OUT Mat& R2, CV_OUT Mat& R3,
-                     CV_OUT Mat& P1, CV_OUT Mat& P2, CV_OUT Mat& P3, CV_OUT Mat& Q,
-                     double alpha, Size newImgSize,
-                     CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags )
-{
-    vector<vector<Point2f> > _imagePoints1;
-    vector<vector<Point2f> > _imagePoints3;
-    mv2vv(imgpt1, _imagePoints1);
-    mv2vv(imgpt3, _imagePoints3);
-    return rectify3Collinear(cameraMatrix1, distCoeffs1,
-                            cameraMatrix2, distCoeffs2,
-                            cameraMatrix3, distCoeffs3,
-                            _imagePoints1, _imagePoints3, imageSize,
-                            R12, T12, R13, T13, R1, R2, R3, P1, P2, P3,
-                            Q, alpha, newImgSize, roi1, roi2, flags);
-}
-*/
- 
-}
-
-#endif
diff --git a/modules/python/test/calchist.py b/modules/python/test/calchist.py
index f379dfec1a..0434f52d2f 100644
--- a/modules/python/test/calchist.py
+++ b/modules/python/test/calchist.py
@@ -1,7 +1,7 @@
 # Calculating and displaying 2D Hue-Saturation histogram of a color image
 
 import sys
-import cv
+import cv2.cv as cv
 
 def hs_histogram(src):
     # Convert to HSV
diff --git a/modules/python/test/camera_calibration.py b/modules/python/test/camera_calibration.py
index 8952e3cc23..989207c8a8 100644
--- a/modules/python/test/camera_calibration.py
+++ b/modules/python/test/camera_calibration.py
@@ -5,7 +5,7 @@ import random
 
 import numpy
 import transformations
-import cv
+import cv2.cv as cv
 
 def clamp(a, x, b):
     return numpy.maximum(a, numpy.minimum(x, b))
diff --git a/modules/python/test/findstereocorrespondence.py b/modules/python/test/findstereocorrespondence.py
index fd3e57f5fc..9cc19412c2 100644
--- a/modules/python/test/findstereocorrespondence.py
+++ b/modules/python/test/findstereocorrespondence.py
@@ -1,5 +1,5 @@
 import sys
-import cv
+import cv2.cv as cv
 
 def findstereocorrespondence(image_left, image_right):
     # image_left and image_right are the input 8-bit single-channel images
diff --git a/modules/python/test/goodfeatures.py b/modules/python/test/goodfeatures.py
index d68bd1f9f9..37f64ac4d3 100644
--- a/modules/python/test/goodfeatures.py
+++ b/modules/python/test/goodfeatures.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import unittest
 
 class TestGoodFeaturesToTrack(unittest.TestCase):
diff --git a/modules/python/test/leak1.py b/modules/python/test/leak1.py
index c451c0e06c..49326dab50 100644
--- a/modules/python/test/leak1.py
+++ b/modules/python/test/leak1.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import numpy as np
 cv.NamedWindow('Leak')
 while 1:
diff --git a/modules/python/test/leak2.py b/modules/python/test/leak2.py
index a67352f197..ca511a40ec 100644
--- a/modules/python/test/leak2.py
+++ b/modules/python/test/leak2.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import numpy as np
 import time
 
diff --git a/modules/python/test/leak3.py b/modules/python/test/leak3.py
index c12364e8e6..901d7be20f 100644
--- a/modules/python/test/leak3.py
+++ b/modules/python/test/leak3.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import math
 import time
 
diff --git a/modules/python/test/leak4.py b/modules/python/test/leak4.py
index 3268200522..8d8ba8883a 100644
--- a/modules/python/test/leak4.py
+++ b/modules/python/test/leak4.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import math
 import time
 
diff --git a/modules/python/test/precornerdetect.py b/modules/python/test/precornerdetect.py
index 4f4da06b17..2d739c3b73 100644
--- a/modules/python/test/precornerdetect.py
+++ b/modules/python/test/precornerdetect.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 
 def precornerdetect(image):
     # assume that the image is floating-point 
diff --git a/modules/python/test/test.py b/modules/python/test/test.py
index 9271aa33a4..92d2dae64a 100644
--- a/modules/python/test/test.py
+++ b/modules/python/test/test.py
@@ -12,7 +12,7 @@ import getopt
 import operator
 import functools
 
-import cv
+import cv2.cv as cv
 
 class OpenCVTests(unittest.TestCase):
 
@@ -940,8 +940,8 @@ class AreaTests(OpenCVTests):
 
             # Using an array object for a CvArr parameter
             ones = numpy.ones((640, 480))
-            r = numpy.ones((640, 480))
-            cv.AddS(ones, 7, r)
+            r = cv.fromarray(numpy.ones((640, 480)))
+            cv.AddS(cv.fromarray(ones), 7, r)
             self.assert_(numpy.alltrue(r == (8 * ones)))
 
             # create arrays, use them in OpenCV and replace the the array
@@ -958,11 +958,12 @@ class AreaTests(OpenCVTests):
 
             # 
             m = numpy.identity(4, dtype = numpy.float32)
+            m = cv.fromarray(m[:3, :3])
             rvec = cv.CreateMat(3, 1, cv.CV_32FC1)
             rvec[0,0] = 1
             rvec[1,0] = 1
             rvec[2,0] = 1
-            cv.Rodrigues2(rvec, m[:3,:3])
+            cv.Rodrigues2(rvec, m)
 	    #print m
 
         else:
diff --git a/modules/python/test/ticket_6.py b/modules/python/test/ticket_6.py
index 5f3d015d88..71534317c9 100644
--- a/modules/python/test/ticket_6.py
+++ b/modules/python/test/ticket_6.py
@@ -1,5 +1,5 @@
 import urllib
-import cv
+import cv2.cv as cv
 import Image
 import unittest
 
diff --git a/modules/python/test/tickets.py b/modules/python/test/tickets.py
index a6f33396c8..aa6818059a 100644
--- a/modules/python/test/tickets.py
+++ b/modules/python/test/tickets.py
@@ -6,7 +6,7 @@ import sys
 import array
 import os
 
-import cv
+import cv2.cv as cv
 
 def find_sample(s):
     for d in ["../samples/c/", "../doc/pics/"]:
diff --git a/modules/refman.rst b/modules/refman.rst
index 6ed01a4cd2..5dc0c13c42 100644
--- a/modules/refman.rst
+++ b/modules/refman.rst
@@ -14,4 +14,5 @@ OpenCV API Reference
    features2d/doc/features2d.rst
    objdetect/doc/objdetect.rst
    ml/doc/ml.rst
+   flann/doc/flann.rst
    gpu/doc/gpu.rst
diff --git a/modules/stitching/blenders.cpp b/modules/stitching/blenders.cpp
index 5797245ca7..99e1b15e30 100644
--- a/modules/stitching/blenders.cpp
+++ b/modules/stitching/blenders.cpp
@@ -47,14 +47,14 @@ using namespace cv;
 
 static const float WEIGHT_EPS = 1e-5f;
 
-Ptr<Blender> Blender::createDefault(int type)
+Ptr<Blender> Blender::createDefault(int type, bool try_gpu)
 {
     if (type == NO)
         return new Blender();
     if (type == FEATHER)
         return new FeatherBlender();
     if (type == MULTI_BAND)
-        return new MultiBandBlender();
+        return new MultiBandBlender(try_gpu);
     CV_Error(CV_StsBadArg, "unsupported blending method");
     return NULL;
 }
@@ -153,6 +153,13 @@ void FeatherBlender::blend(Mat &dst, Mat &dst_mask)
 }
 
 
+MultiBandBlender::MultiBandBlender(int try_gpu, int num_bands)
+{
+    setNumBands(num_bands);
+    can_use_gpu_ = try_gpu && gpu::getCudaEnabledDeviceCount();
+}
+
+
 void MultiBandBlender::prepare(Rect dst_roi)
 {
     dst_roi_final_ = dst_roi;
@@ -222,14 +229,11 @@ void MultiBandBlender::feed(const Mat &img, const Mat &mask, Point tl)
     int right = br_new.x - tl.x - img.cols;
 
     // Create the source image Laplacian pyramid
-    vector<Mat> src_pyr_gauss(num_bands_ + 1);
-    copyMakeBorder(img, src_pyr_gauss[0], top, bottom, left, right, 
+    Mat img_with_border;
+    copyMakeBorder(img, img_with_border, top, bottom, left, right,
                    BORDER_REFLECT);
-    for (int i = 0; i < num_bands_; ++i)
-        pyrDown(src_pyr_gauss[i], src_pyr_gauss[i + 1]);
     vector<Mat> src_pyr_laplace;
-    createLaplacePyr(src_pyr_gauss, src_pyr_laplace);
-    src_pyr_gauss.clear();
+    createLaplacePyr(img_with_border, num_bands_, src_pyr_laplace);
 
     // Create the weight map Gaussian pyramid
     Mat weight_map;
@@ -267,7 +271,7 @@ void MultiBandBlender::feed(const Mat &img, const Mat &mask, Point tl)
         }
         x_tl /= 2; y_tl /= 2; 
         x_br /= 2; y_br /= 2;
-    }    
+    }
 }
 
 
@@ -319,21 +323,44 @@ void createWeightMap(const Mat &mask, float sharpness, Mat &weight)
 }
 
 
-void createLaplacePyr(const vector<Mat> &pyr_gauss, vector<Mat> &pyr_laplace)
+void createLaplacePyr(const Mat &img, int num_levels, vector<Mat> &pyr)
 {
-    if (pyr_gauss.size() == 0)
-        return;
-    pyr_laplace.resize(pyr_gauss.size());
+    pyr.resize(num_levels + 1);
+    pyr[0] = img;
+    for (int i = 0; i < num_levels; ++i)
+        pyrDown(pyr[i], pyr[i + 1]);
     Mat tmp;
-    for (size_t i = 0; i < pyr_laplace.size() - 1; ++i)
+    for (int i = 0; i < num_levels; ++i)
     {
-        pyrUp(pyr_gauss[i + 1], tmp, pyr_gauss[i].size());
-        subtract(pyr_gauss[i], tmp, pyr_laplace[i]);
+        pyrUp(pyr[i + 1], tmp, pyr[i].size());
+        subtract(pyr[i], tmp, pyr[i]);
     }
-    pyr_laplace[pyr_laplace.size() - 1] = pyr_gauss[pyr_laplace.size() - 1].clone();
 }
 
 
+#if 0
+void createLaplacePyrGpu(const Mat &img, int num_levels, vector<Mat> &pyr)
+{
+    pyr.resize(num_levels + 1);
+
+    vector<gpu::GpuMat> gpu_pyr(num_levels + 1);
+    gpu_pyr[0] = img;
+    for (int i = 0; i < num_levels; ++i)
+        gpu::pyrDown(gpu_pyr[i], gpu_pyr[i + 1]);
+
+    gpu::GpuMat tmp;
+    for (int i = 0; i < num_levels; ++i)
+    {
+        gpu::pyrUp(gpu_pyr[i + 1], tmp);
+        gpu::subtract(gpu_pyr[i], tmp, gpu_pyr[i]);
+        pyr[i] = gpu_pyr[i];
+    }
+
+    pyr[num_levels] = gpu_pyr[num_levels];
+}
+#endif
+
+
 void restoreImageFromLaplacePyr(vector<Mat> &pyr)
 {
     if (pyr.size() == 0)
diff --git a/modules/stitching/blenders.hpp b/modules/stitching/blenders.hpp
index a6fd0eceb5..af52f8a939 100644
--- a/modules/stitching/blenders.hpp
+++ b/modules/stitching/blenders.hpp
@@ -38,77 +38,83 @@
 // 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_BLENDERS_HPP__
-#define __OPENCV_BLENDERS_HPP__
-
-#include "precomp.hpp"
-
-// Simple blender which puts one image over another
-class Blender
-{
-public:
-    enum { NO, FEATHER, MULTI_BAND };
-    static cv::Ptr<Blender> createDefault(int type);
-
-    void prepare(const std::vector<cv::Point> &corners, const std::vector<cv::Size> &sizes);
-    virtual void prepare(cv::Rect dst_roi);
-    virtual void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
-    virtual void blend(cv::Mat &dst, cv::Mat &dst_mask);
-
-protected:
-    cv::Mat dst_, dst_mask_;
-    cv::Rect dst_roi_;
-};
-
-
-class FeatherBlender : public Blender
-{
-public:
-    FeatherBlender(float sharpness = 0.02f) { setSharpness(sharpness); }
-    float sharpness() const { return sharpness_; }
-    void setSharpness(float val) { sharpness_ = val; }
-
-    void prepare(cv::Rect dst_roi);
-    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
-    void blend(cv::Mat &dst, cv::Mat &dst_mask);
-
-private:
-    float sharpness_;
-    cv::Mat weight_map_;
-    cv::Mat dst_weight_map_;
-};
-
-
-class MultiBandBlender : public Blender
-{
-public:
-    MultiBandBlender(int num_bands = 5) { setNumBands(num_bands); }
-    int numBands() const { return actual_num_bands_; }
-    void setNumBands(int val) { actual_num_bands_ = val; }
-
-    void prepare(cv::Rect dst_roi);
-    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
-    void blend(cv::Mat &dst, cv::Mat &dst_mask);
-
-private:
-    int actual_num_bands_, num_bands_;
-    std::vector<cv::Mat> dst_pyr_laplace_;
-    std::vector<cv::Mat> dst_band_weights_;
-    cv::Rect dst_roi_final_;
-};
-
-
-//////////////////////////////////////////////////////////////////////////////
-// Auxiliary functions
-
-void normalize(const cv::Mat& weight, cv::Mat& src);
-
-void createWeightMap(const cv::Mat& mask, float sharpness, cv::Mat& weight);
-
-void createLaplacePyr(const std::vector<cv::Mat>& pyr_gauss, std::vector<cv::Mat>& pyr_laplace);
-
-// Restores source image in-place (result will be stored in pyr[0])
-void restoreImageFromLaplacePyr(std::vector<cv::Mat>& pyr);
-
-#endif // __OPENCV_BLENDERS_HPP__
+//M*/
+#ifndef __OPENCV_BLENDERS_HPP__
+#define __OPENCV_BLENDERS_HPP__
+
+#include "precomp.hpp"
+
+// Simple blender which puts one image over another
+class Blender
+{
+public:
+    enum { NO, FEATHER, MULTI_BAND };
+    static cv::Ptr<Blender> createDefault(int type, bool try_gpu = false);
+
+    void prepare(const std::vector<cv::Point> &corners, const std::vector<cv::Size> &sizes);
+    virtual void prepare(cv::Rect dst_roi);
+    virtual void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    virtual void blend(cv::Mat &dst, cv::Mat &dst_mask);
+
+protected:
+    cv::Mat dst_, dst_mask_;
+    cv::Rect dst_roi_;
+};
+
+
+class FeatherBlender : public Blender
+{
+public:
+    FeatherBlender(float sharpness = 0.02f) { setSharpness(sharpness); }
+    float sharpness() const { return sharpness_; }
+    void setSharpness(float val) { sharpness_ = val; }
+
+    void prepare(cv::Rect dst_roi);
+    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    void blend(cv::Mat &dst, cv::Mat &dst_mask);
+
+private:
+    float sharpness_;
+    cv::Mat weight_map_;
+    cv::Mat dst_weight_map_;
+};
+
+
+class MultiBandBlender : public Blender
+{
+public:
+    MultiBandBlender(int try_gpu = false, int num_bands = 5);
+    int numBands() const { return actual_num_bands_; }
+    void setNumBands(int val) { actual_num_bands_ = val; }
+
+    void prepare(cv::Rect dst_roi);
+    void feed(const cv::Mat &img, const cv::Mat &mask, cv::Point tl);
+    void blend(cv::Mat &dst, cv::Mat &dst_mask);
+
+private:
+    int actual_num_bands_, num_bands_;
+    std::vector<cv::Mat> dst_pyr_laplace_;
+    std::vector<cv::Mat> dst_band_weights_;
+    cv::Rect dst_roi_final_;
+    bool can_use_gpu_;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Auxiliary functions
+
+void normalize(const cv::Mat& weight, cv::Mat& src);
+
+void createWeightMap(const cv::Mat& mask, float sharpness, cv::Mat& weight);
+
+void createLaplacePyr(const cv::Mat &img, int num_levels, std::vector<cv::Mat>& pyr);
+
+// TODO Use it after gpu::pyrDown and gpu::pyrUp are updated
+#if 0
+void createLaplacePyrGpu(const cv::Mat &img, int num_levels, std::vector<cv::Mat>& pyr);
+#endif
+
+// Restores source image in-place (result will be stored in pyr[0])
+void restoreImageFromLaplacePyr(std::vector<cv::Mat>& pyr);
+
+#endif // __OPENCV_BLENDERS_HPP__
diff --git a/modules/stitching/main.cpp b/modules/stitching/main.cpp
index 7c4922887e..fbd4657b39 100644
--- a/modules/stitching/main.cpp
+++ b/modules/stitching/main.cpp
@@ -40,7 +40,7 @@
 //
 //M*/
 
-// We follow to methods described in these two papers:
+// We follow to these papers:
 // 1) Construction of panoramic mosaics with global and local alignment. 
 //    Heung-Yeung Shum and Richard Szeliski. 2000.
 // 2) Eliminating Ghosting and Exposure Artifacts in Image Mosaics. 
@@ -363,6 +363,8 @@ int main(int argc, char* argv[])
         images[i] = img.clone();
     }
 
+    finder.releaseMemory();
+
     full_img.release();
     img.release();
 
@@ -373,6 +375,7 @@ int main(int argc, char* argv[])
     vector<MatchesInfo> pairwise_matches;
     BestOf2NearestMatcher matcher(try_gpu, match_conf);
     matcher(features, pairwise_matches);
+    matcher.releaseMemory();
     LOGLN("Pairwise matching, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
     // Leave only images we are sure are from the same panorama
@@ -461,7 +464,7 @@ int main(int argc, char* argv[])
 
     // Warp images and their masks
     Ptr<Warper> warper = Warper::createByCameraFocal(static_cast<float>(warped_image_scale * seam_work_aspect), 
-                                                     warp_type);
+                                                     warp_type, try_gpu);
     for (int i = 0; i < num_images; ++i)
     {
         corners[i] = warper->warp(images[i], static_cast<float>(cameras[i].focal * seam_work_aspect), 
@@ -522,7 +525,7 @@ int main(int argc, char* argv[])
 
             // Update warped image scale
             warped_image_scale *= static_cast<float>(compose_work_aspect);
-            warper = Warper::createByCameraFocal(warped_image_scale, warp_type);
+            warper = Warper::createByCameraFocal(warped_image_scale, warp_type, try_gpu);
 
             // Update corners and sizes
             for (int i = 0; i < num_images; ++i)
@@ -547,7 +550,7 @@ int main(int argc, char* argv[])
         else
             img = full_img;
         full_img.release();
-        Size img_size = img.size();
+        Size img_size = img.size();                
 
         // Warp the current image
         warper->warp(img, static_cast<float>(cameras[img_idx].focal), cameras[img_idx].R,
@@ -565,19 +568,19 @@ int main(int argc, char* argv[])
         img_warped.convertTo(img_warped_s, CV_16S);
         img_warped.release();
         img.release();
-        mask.release();
+        mask.release();       
 
         dilate(masks_warped[img_idx], dilated_mask, Mat());
         resize(dilated_mask, seam_mask, mask_warped.size());
         mask_warped = seam_mask & mask_warped;
 
-        if (static_cast<Blender*>(blender) == 0)
-        {
-            blender = Blender::createDefault(blend_type);
+        if (blender.empty())
+        {            
+            blender = Blender::createDefault(blend_type, try_gpu);
             Size dst_sz = resultRoi(corners, sizes).size();
             float blend_width = sqrt(static_cast<float>(dst_sz.area())) * blend_strength / 100.f;
             if (blend_width < 1.f)
-                blender = Blender::createDefault(Blender::NO);
+                blender = Blender::createDefault(Blender::NO, try_gpu);
             else if (blend_type == Blender::MULTI_BAND)
             {
                 MultiBandBlender* mb = dynamic_cast<MultiBandBlender*>(static_cast<Blender*>(blender));
@@ -594,11 +597,11 @@ int main(int argc, char* argv[])
         }
 
         // Blend the current image
-        blender->feed(img_warped_s, mask_warped, corners[img_idx]);
+        blender->feed(img_warped_s, mask_warped, corners[img_idx]);        
     }
    
     Mat result, result_mask;
-    blender->blend(result, result_mask);    
+    blender->blend(result, result_mask);
 
     LOGLN("Compositing, time: " << ((getTickCount() - t) / getTickFrequency()) << " sec");
 
diff --git a/modules/stitching/matchers.cpp b/modules/stitching/matchers.cpp
index 07c8fb958c..b0438869af 100644
--- a/modules/stitching/matchers.cpp
+++ b/modules/stitching/matchers.cpp
@@ -96,11 +96,17 @@ namespace
             num_layers_descr_ = num_layers_descr;
         }
 
+        void releaseMemory();
+
     protected:
         void find(const Mat &image, ImageFeatures &features);
 
     private:
+        GpuMat image_;
+        GpuMat gray_image_;
         SURF_GPU surf_;
+        GpuMat keypoints_;
+        GpuMat descriptors_;
         int num_octaves_, num_layers_;
         int num_octaves_descr_, num_layers_descr_;
     };
@@ -118,22 +124,34 @@ namespace
 
     void GpuSurfFeaturesFinder::find(const Mat &image, ImageFeatures &features)
     {
-        GpuMat gray_image;
         CV_Assert(image.depth() == CV_8U);
-        cvtColor(GpuMat(image), gray_image, CV_BGR2GRAY);
 
-        GpuMat d_keypoints;
-        GpuMat d_descriptors;
+        ensureSizeIsEnough(image.size(), image.type(), image_);
+        image_.upload(image);
+
+        ensureSizeIsEnough(image.size(), CV_8UC1, gray_image_);
+        cvtColor(image_, gray_image_, CV_BGR2GRAY);
+
         surf_.nOctaves = num_octaves_;
         surf_.nOctaveLayers = num_layers_;
-        surf_(gray_image, GpuMat(), d_keypoints);
+        surf_(gray_image_, GpuMat(), keypoints_);
 
         surf_.nOctaves = num_octaves_descr_;
         surf_.nOctaveLayers = num_layers_descr_;
-        surf_(gray_image, GpuMat(), d_keypoints, d_descriptors, true);
-        surf_.downloadKeypoints(d_keypoints, features.keypoints);
+        surf_.upright = true;
+        surf_(gray_image_, GpuMat(), keypoints_, descriptors_, true);
+        surf_.downloadKeypoints(keypoints_, features.keypoints);
 
-        d_descriptors.download(features.descriptors);
+        descriptors_.download(features.descriptors);
+    }
+
+    void GpuSurfFeaturesFinder::releaseMemory()
+    {
+        surf_.releaseMemory();
+        image_.release();
+        gray_image_.release();
+        keypoints_.release();
+        descriptors_.release();
     }
 } // anonymous namespace
 
@@ -153,6 +171,11 @@ void SurfFeaturesFinder::find(const Mat &image, ImageFeatures &features)
     (*impl_)(image, features);
 }
 
+void SurfFeaturesFinder::releaseMemory()
+{
+    impl_->releaseMemory();
+}
+
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -257,15 +280,7 @@ void FeaturesMatcher::operator ()(const vector<ImageFeatures> &features, vector<
 
 namespace 
 {
-    class PairLess
-    {
-    public:
-        bool operator()(const pair<int,int>& l, const pair<int,int>& r) const
-        {
-            return l.first < r.first || (l.first == r.first && l.second < r.second);
-        }
-    };
-    typedef set<pair<int,int>,PairLess> MatchesSet;
+    typedef set<pair<int,int> > MatchesSet;
 
     // These two classes are aimed to find features matches only, not to 
     // estimate homography
@@ -287,10 +302,13 @@ namespace
         GpuMatcher(float match_conf) : match_conf_(match_conf) {}
         void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info);
 
+        void releaseMemory();
+
     private:
         float match_conf_;
         GpuMat descriptors1_, descriptors2_;
         GpuMat train_idx_, distance_, all_dist_;
+        vector< vector<DMatch> > pair_matches;
     };
 
 
@@ -334,14 +352,19 @@ namespace
 
     void GpuMatcher::match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo& matches_info)
     {
-        matches_info.matches.clear();       
+        matches_info.matches.clear(); 
+
+        ensureSizeIsEnough(features1.descriptors.size(), features1.descriptors.type(), descriptors1_);
+        ensureSizeIsEnough(features2.descriptors.size(), features2.descriptors.type(), descriptors2_);
+
         descriptors1_.upload(features1.descriptors);
         descriptors2_.upload(features2.descriptors);
+
         BruteForceMatcher_GPU< L2<float> > matcher;
-        vector< vector<DMatch> > pair_matches;
         MatchesSet matches;
 
         // Find 1->2 matches
+        pair_matches.clear();
         matcher.knnMatch(descriptors1_, descriptors2_, train_idx_, distance_, all_dist_, 2);
         matcher.knnMatchDownload(train_idx_, distance_, pair_matches);
         for (size_t i = 0; i < pair_matches.size(); ++i)
@@ -373,12 +396,30 @@ namespace
         }
     }
 
+    void GpuMatcher::releaseMemory()
+    {
+        descriptors1_.release();
+        descriptors2_.release();
+        train_idx_.release();
+        distance_.release();
+        all_dist_.release();
+        vector< vector<DMatch> >().swap(pair_matches);
+    }
+
 } // anonymous namespace
 
 
 BestOf2NearestMatcher::BestOf2NearestMatcher(bool try_use_gpu, float match_conf, int num_matches_thresh1, int num_matches_thresh2)
 {
+    bool use_gpu = false;
     if (try_use_gpu && getCudaEnabledDeviceCount() > 0)
+    {
+        DeviceInfo info;
+        if (info.majorVersion() >= 2 && cv::getNumberOfCPUs() < 4)
+            use_gpu = true;
+    }
+
+    if (use_gpu)
         impl_ = new GpuMatcher(match_conf);
     else
         impl_ = new CpuMatcher(match_conf);
@@ -405,8 +446,8 @@ void BestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFea
         return;
 
     // Construct point-point correspondences for homography estimation
-    Mat src_points(1, matches_info.matches.size(), CV_32FC2);
-    Mat dst_points(1, matches_info.matches.size(), CV_32FC2);
+    Mat src_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
+    Mat dst_points(1, static_cast<int>(matches_info.matches.size()), CV_32FC2);
     for (size_t i = 0; i < matches_info.matches.size(); ++i)
     {
         const DMatch& m = matches_info.matches[i];
@@ -414,12 +455,12 @@ void BestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFea
         Point2f p = features1.keypoints[m.queryIdx].pt;
         p.x -= features1.img_size.width * 0.5f;
         p.y -= features1.img_size.height * 0.5f;
-        src_points.at<Point2f>(0, i) = p;
+        src_points.at<Point2f>(0, static_cast<int>(i)) = p;
 
         p = features2.keypoints[m.trainIdx].pt;
         p.x -= features2.img_size.width * 0.5f;
         p.y -= features2.img_size.height * 0.5f;
-        dst_points.at<Point2f>(0, i) = p;
+        dst_points.at<Point2f>(0, static_cast<int>(i)) = p;
     }
 
     // Find pair-wise motion
@@ -464,3 +505,8 @@ void BestOf2NearestMatcher::match(const ImageFeatures &features1, const ImageFea
     // Rerun motion estimation on inliers only
     matches_info.H = findHomography(src_points, dst_points, CV_RANSAC);
 }
+
+void BestOf2NearestMatcher::releaseMemory()
+{
+    impl_->releaseMemory();
+}
diff --git a/modules/stitching/matchers.hpp b/modules/stitching/matchers.hpp
index 601043fa28..fe7fbe060e 100644
--- a/modules/stitching/matchers.hpp
+++ b/modules/stitching/matchers.hpp
@@ -59,6 +59,8 @@ public:
     virtual ~FeaturesFinder() {}
     void operator ()(const cv::Mat &image, ImageFeatures &features);
 
+    virtual void releaseMemory() {}
+
 protected:
     virtual void find(const cv::Mat &image, ImageFeatures &features) = 0;
 };
@@ -71,6 +73,8 @@ public:
                        int num_octaves = 3, int num_layers = 4, 
                        int num_octaves_descr = 4, int num_layers_descr = 2);
 
+    void releaseMemory();
+
 protected:
     void find(const cv::Mat &image, ImageFeatures &features);
 
@@ -104,6 +108,8 @@ public:
 
     bool isThreadSafe() const { return is_thread_safe_; }
 
+    virtual void releaseMemory() {}
+
 protected:
     FeaturesMatcher(bool is_thread_safe = false) : is_thread_safe_(is_thread_safe) {}
 
@@ -120,6 +126,8 @@ public:
     BestOf2NearestMatcher(bool try_use_gpu = true, float match_conf = 0.55f, int num_matches_thresh1 = 6, 
                           int num_matches_thresh2 = 6);
 
+    void releaseMemory();
+
 protected:
     void match(const ImageFeatures &features1, const ImageFeatures &features2, MatchesInfo &matches_info);
 
diff --git a/modules/stitching/motion_estimators.cpp b/modules/stitching/motion_estimators.cpp
index 763c4a68d6..08d1aaec26 100644
--- a/modules/stitching/motion_estimators.cpp
+++ b/modules/stitching/motion_estimators.cpp
@@ -405,7 +405,7 @@ vector<int> leaveBiggestComponent(vector<ImageFeatures> &features,  vector<Match
         }
     }
 
-    int max_comp = max_element(comps.size.begin(), comps.size.end()) - comps.size.begin();
+    int max_comp = static_cast<int>(max_element(comps.size.begin(), comps.size.end()) - comps.size.begin());
 
     vector<int> indices;
     vector<int> indices_removed;
@@ -423,8 +423,8 @@ vector<int> leaveBiggestComponent(vector<ImageFeatures> &features,  vector<Match
         for (size_t j = 0; j < indices.size(); ++j)
         {
             pairwise_matches_subset.push_back(pairwise_matches[indices[i]*num_images + indices[j]]);
-            pairwise_matches_subset.back().src_img_idx = i;
-            pairwise_matches_subset.back().dst_img_idx = j;
+            pairwise_matches_subset.back().src_img_idx = static_cast<int>(i);
+            pairwise_matches_subset.back().dst_img_idx = static_cast<int>(j);
         }
     }
 
diff --git a/modules/stitching/precomp.hpp b/modules/stitching/precomp.hpp
index 340342267f..16bdf6048c 100644
--- a/modules/stitching/precomp.hpp
+++ b/modules/stitching/precomp.hpp
@@ -50,6 +50,7 @@
 #include <algorithm>
 #include <utility>
 #include <set>
+#include <functional>
 #include "opencv2/core/core.hpp"
 #include "opencv2/core/internal.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
diff --git a/modules/stitching/warpers.cpp b/modules/stitching/warpers.cpp
index 9487c54d60..aceedac53c 100644
--- a/modules/stitching/warpers.cpp
+++ b/modules/stitching/warpers.cpp
@@ -38,111 +38,174 @@
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
-//M*/
-#include "warpers.hpp"
-
-using namespace std;
-using namespace cv;
-
-Ptr<Warper> Warper::createByCameraFocal(float focal, int type)
-{
-    if (type == PLANE)
-        return new PlaneWarper(focal);
-    if (type == CYLINDRICAL)
-        return new CylindricalWarper(focal);
-    if (type == SPHERICAL)
-        return new SphericalWarper(focal);
-    CV_Error(CV_StsBadArg, "unsupported warping type");
-    return NULL;
-}
-
-
-void ProjectorBase::setTransformation(const Mat &R)
-{
-    CV_Assert(R.size() == Size(3, 3));
-    CV_Assert(R.type() == CV_32F);
-    r[0] = R.at<float>(0, 0); r[1] = R.at<float>(0, 1); r[2] = R.at<float>(0, 2);
-    r[3] = R.at<float>(1, 0); r[4] = R.at<float>(1, 1); r[5] = R.at<float>(1, 2);
-    r[6] = R.at<float>(2, 0); r[7] = R.at<float>(2, 1); r[8] = R.at<float>(2, 2);
-
-    Mat Rinv = R.inv();
-    rinv[0] = Rinv.at<float>(0, 0); rinv[1] = Rinv.at<float>(0, 1); rinv[2] = Rinv.at<float>(0, 2);
-    rinv[3] = Rinv.at<float>(1, 0); rinv[4] = Rinv.at<float>(1, 1); rinv[5] = Rinv.at<float>(1, 2);
-    rinv[6] = Rinv.at<float>(2, 0); rinv[7] = Rinv.at<float>(2, 1); rinv[8] = Rinv.at<float>(2, 2);
-}
-
-
-void PlaneWarper::detectResultRoi(Point &dst_tl, Point &dst_br)
-{
-    float tl_uf = numeric_limits<float>::max();
-    float tl_vf = numeric_limits<float>::max();
-    float br_uf = -numeric_limits<float>::max();
-    float br_vf = -numeric_limits<float>::max();
-
-    float u, v;
-
-    projector_.mapForward(0, 0, u, v);
-    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
-    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
-
-    projector_.mapForward(0, static_cast<float>(src_size_.height - 1), u, v);
-    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
-    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
-
-    projector_.mapForward(static_cast<float>(src_size_.width - 1), 0, u, v);
-    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
-    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
-
-    projector_.mapForward(static_cast<float>(src_size_.width - 1), static_cast<float>(src_size_.height - 1), u, v);
-    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
-    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
-
-    dst_tl.x = static_cast<int>(tl_uf);
-    dst_tl.y = static_cast<int>(tl_vf);
-    dst_br.x = static_cast<int>(br_uf);
-    dst_br.y = static_cast<int>(br_vf);
-}
-
-
-void SphericalWarper::detectResultRoi(Point &dst_tl, Point &dst_br)
-{
-    detectResultRoiByBorder(dst_tl, dst_br);
-
-    float tl_uf = static_cast<float>(dst_tl.x);
-    float tl_vf = static_cast<float>(dst_tl.y);
-    float br_uf = static_cast<float>(dst_br.x);
-    float br_vf = static_cast<float>(dst_br.y);
-
-    float x = projector_.rinv[1];
-    float y = projector_.rinv[4];
-    float z = projector_.rinv[7];
-    if (y > 0.f)
-    {
-        x = projector_.focal * x / z + src_size_.width * 0.5f;
-        y = projector_.focal * y / z + src_size_.height * 0.5f;
-        if (x > 0.f && x < src_size_.width && y > 0.f && y < src_size_.height)
-        {
-            tl_uf = min(tl_uf, 0.f); tl_vf = min(tl_vf, static_cast<float>(CV_PI * projector_.scale));
-            br_uf = max(br_uf, 0.f); br_vf = max(br_vf, static_cast<float>(CV_PI * projector_.scale));
-        }
-    }
-
-    x = projector_.rinv[1];
-    y = -projector_.rinv[4];
-    z = projector_.rinv[7];
-    if (y > 0.f)
-    {
-        x = projector_.focal * x / z + src_size_.width * 0.5f;
-        y = projector_.focal * y / z + src_size_.height * 0.5f;
-        if (x > 0.f && x < src_size_.width && y > 0.f && y < src_size_.height)
-        {
-            tl_uf = min(tl_uf, 0.f); tl_vf = min(tl_vf, static_cast<float>(0));
-            br_uf = max(br_uf, 0.f); br_vf = max(br_vf, static_cast<float>(0));
-        }
-    }
-
-    dst_tl.x = static_cast<int>(tl_uf);
-    dst_tl.y = static_cast<int>(tl_vf);
-    dst_br.x = static_cast<int>(br_uf);
-    dst_br.y = static_cast<int>(br_vf);
-}
+//M*/
+#include "warpers.hpp"
+
+using namespace std;
+using namespace cv;
+
+Ptr<Warper> Warper::createByCameraFocal(float focal, int type, bool try_gpu)
+{
+    bool can_use_gpu = try_gpu && gpu::getCudaEnabledDeviceCount();
+    if (type == PLANE)
+        return !can_use_gpu ? new PlaneWarper(focal) : new PlaneWarperGpu(focal);
+    if (type == CYLINDRICAL)
+        return !can_use_gpu ? new CylindricalWarper(focal) : new CylindricalWarperGpu(focal);
+    if (type == SPHERICAL)
+        return !can_use_gpu ? new SphericalWarper(focal) : new SphericalWarperGpu(focal);
+    CV_Error(CV_StsBadArg, "unsupported warping type");
+    return NULL;
+}
+
+
+void ProjectorBase::setTransformation(const Mat &R)
+{
+    CV_Assert(R.size() == Size(3, 3));
+    CV_Assert(R.type() == CV_32F);
+    r[0] = R.at<float>(0, 0); r[1] = R.at<float>(0, 1); r[2] = R.at<float>(0, 2);
+    r[3] = R.at<float>(1, 0); r[4] = R.at<float>(1, 1); r[5] = R.at<float>(1, 2);
+    r[6] = R.at<float>(2, 0); r[7] = R.at<float>(2, 1); r[8] = R.at<float>(2, 2);
+
+    Mat Rinv = R.inv();
+    rinv[0] = Rinv.at<float>(0, 0); rinv[1] = Rinv.at<float>(0, 1); rinv[2] = Rinv.at<float>(0, 2);
+    rinv[3] = Rinv.at<float>(1, 0); rinv[4] = Rinv.at<float>(1, 1); rinv[5] = Rinv.at<float>(1, 2);
+    rinv[6] = Rinv.at<float>(2, 0); rinv[7] = Rinv.at<float>(2, 1); rinv[8] = Rinv.at<float>(2, 2);
+}
+
+
+void PlaneWarper::detectResultRoi(Point &dst_tl, Point &dst_br)
+{
+    float tl_uf = numeric_limits<float>::max();
+    float tl_vf = numeric_limits<float>::max();
+    float br_uf = -numeric_limits<float>::max();
+    float br_vf = -numeric_limits<float>::max();
+
+    float u, v;
+
+    projector_.mapForward(0, 0, u, v);
+    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
+    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
+
+    projector_.mapForward(0, static_cast<float>(src_size_.height - 1), u, v);
+    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
+    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
+
+    projector_.mapForward(static_cast<float>(src_size_.width - 1), 0, u, v);
+    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
+    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
+
+    projector_.mapForward(static_cast<float>(src_size_.width - 1), static_cast<float>(src_size_.height - 1), u, v);
+    tl_uf = min(tl_uf, u); tl_vf = min(tl_vf, v);
+    br_uf = max(br_uf, u); br_vf = max(br_vf, v);
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+
+Point PlaneWarperGpu::warp(const Mat &src, float focal, const cv::Mat &R, cv::Mat &dst, int interp_mode, int border_mode)
+{
+    src_size_ = src.size();
+    projector_.size = src.size();
+    projector_.focal = focal;
+    projector_.setTransformation(R);
+
+    cv::Point dst_tl, dst_br;
+    detectResultRoi(dst_tl, dst_br);
+
+    gpu::buildWarpPlaneMaps(src.size(), Rect(dst_tl, Point(dst_br.x+1, dst_br.y+1)),
+                            R, focal, projector_.scale, projector_.plane_dist, d_xmap_, d_ymap_);
+
+    dst.create(dst_br.y - dst_tl.y + 1, dst_br.x - dst_tl.x + 1, src.type());
+    remap(src, dst, Mat(d_xmap_), Mat(d_ymap_), interp_mode, border_mode);
+
+    return dst_tl;
+}
+
+
+void SphericalWarper::detectResultRoi(Point &dst_tl, Point &dst_br)
+{
+    detectResultRoiByBorder(dst_tl, dst_br);
+
+    float tl_uf = static_cast<float>(dst_tl.x);
+    float tl_vf = static_cast<float>(dst_tl.y);
+    float br_uf = static_cast<float>(dst_br.x);
+    float br_vf = static_cast<float>(dst_br.y);
+
+    float x = projector_.rinv[1];
+    float y = projector_.rinv[4];
+    float z = projector_.rinv[7];
+    if (y > 0.f)
+    {
+        x = projector_.focal * x / z + src_size_.width * 0.5f;
+        y = projector_.focal * y / z + src_size_.height * 0.5f;
+        if (x > 0.f && x < src_size_.width && y > 0.f && y < src_size_.height)
+        {
+            tl_uf = min(tl_uf, 0.f); tl_vf = min(tl_vf, static_cast<float>(CV_PI * projector_.scale));
+            br_uf = max(br_uf, 0.f); br_vf = max(br_vf, static_cast<float>(CV_PI * projector_.scale));
+        }
+    }
+
+    x = projector_.rinv[1];
+    y = -projector_.rinv[4];
+    z = projector_.rinv[7];
+    if (y > 0.f)
+    {
+        x = projector_.focal * x / z + src_size_.width * 0.5f;
+        y = projector_.focal * y / z + src_size_.height * 0.5f;
+        if (x > 0.f && x < src_size_.width && y > 0.f && y < src_size_.height)
+        {
+            tl_uf = min(tl_uf, 0.f); tl_vf = min(tl_vf, static_cast<float>(0));
+            br_uf = max(br_uf, 0.f); br_vf = max(br_vf, static_cast<float>(0));
+        }
+    }
+
+    dst_tl.x = static_cast<int>(tl_uf);
+    dst_tl.y = static_cast<int>(tl_vf);
+    dst_br.x = static_cast<int>(br_uf);
+    dst_br.y = static_cast<int>(br_vf);
+}
+
+
+Point SphericalWarperGpu::warp(const Mat &src, float focal, const Mat &R, Mat &dst,
+                               int interp_mode, int border_mode)
+{
+    src_size_ = src.size();
+    projector_.size = src.size();
+    projector_.focal = focal;
+    projector_.setTransformation(R);
+
+    cv::Point dst_tl, dst_br;
+    detectResultRoi(dst_tl, dst_br);
+
+    gpu::buildWarpSphericalMaps(src.size(), Rect(dst_tl, Point(dst_br.x+1, dst_br.y+1)),
+                                R, focal, projector_.scale, d_xmap_, d_ymap_);
+
+    dst.create(dst_br.y - dst_tl.y + 1, dst_br.x - dst_tl.x + 1, src.type());
+    remap(src, dst, Mat(d_xmap_), Mat(d_ymap_), interp_mode, border_mode);
+
+    return dst_tl;
+}
+
+
+Point CylindricalWarperGpu::warp(const Mat &src, float focal, const Mat &R, Mat &dst,
+                                 int interp_mode, int border_mode)
+{
+    src_size_ = src.size();
+    projector_.size = src.size();
+    projector_.focal = focal;
+    projector_.setTransformation(R);
+
+    cv::Point dst_tl, dst_br;
+    detectResultRoi(dst_tl, dst_br);
+
+    gpu::buildWarpCylindricalMaps(src.size(), Rect(dst_tl, Point(dst_br.x+1, dst_br.y+1)),
+                                  R, focal, projector_.scale, d_xmap_, d_ymap_);
+
+    dst.create(dst_br.y - dst_tl.y + 1, dst_br.x - dst_tl.x + 1, src.type());
+    remap(src, dst, Mat(d_xmap_), Mat(d_ymap_), interp_mode, border_mode);
+
+    return dst_tl;
+}
diff --git a/modules/stitching/warpers.hpp b/modules/stitching/warpers.hpp
index 597ee4fa29..47a162e6c7 100644
--- a/modules/stitching/warpers.hpp
+++ b/modules/stitching/warpers.hpp
@@ -1,4 +1,4 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
+ /*M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
@@ -48,7 +48,7 @@ class Warper
 {
 public:
     enum { PLANE, CYLINDRICAL, SPHERICAL };
-    static cv::Ptr<Warper> createByCameraFocal(float focal, int type);
+    static cv::Ptr<Warper> createByCameraFocal(float focal, int type, bool try_gpu = false);
 
     virtual ~Warper() {}
     virtual cv::Point warp(const cv::Mat &src, float focal, const cv::Mat& R, cv::Mat &dst,
@@ -73,10 +73,10 @@ template <class P>
 class WarperBase : public Warper
 {   
 public:
-    cv::Point warp(const cv::Mat &src, float focal, const cv::Mat &R, cv::Mat &dst,
-                   int interp_mode, int border_mode);
+    virtual cv::Point warp(const cv::Mat &src, float focal, const cv::Mat &R, cv::Mat &dst,
+                           int interp_mode, int border_mode);
 
-    cv::Rect warpRoi(const cv::Size &sz, float focal, const cv::Mat &R);
+    virtual cv::Rect warpRoi(const cv::Size &sz, float focal, const cv::Mat &R);
 
 protected:
     // Detects ROI of the destination image. It's correct for any projection.
@@ -95,7 +95,6 @@ struct PlaneProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
     void mapBackward(float u, float v, float &x, float &y);
-
     float plane_dist;
 };
 
@@ -110,11 +109,23 @@ public:
         projector_.scale = scale;
     }
 
-private:
+protected:
     void detectResultRoi(cv::Point &dst_tl, cv::Point &dst_br);
 };
 
 
+class PlaneWarperGpu : public PlaneWarper
+{
+public:
+    PlaneWarperGpu(float plane_dist = 1.f, float scale = 1.f) : PlaneWarper(plane_dist, scale) {}
+    cv::Point warp(const cv::Mat &src, float focal, const cv::Mat &R, cv::Mat &dst,
+                   int interp_mode, int border_mode);
+
+private:
+    cv::gpu::GpuMat d_xmap_, d_ymap_, d_dst_;
+};
+
+
 struct SphericalProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
@@ -129,11 +140,23 @@ class SphericalWarper : public WarperBase<SphericalProjector>
 public:
     SphericalWarper(float scale = 300.f) { projector_.scale = scale; }
 
-private:  
+protected:
     void detectResultRoi(cv::Point &dst_tl, cv::Point &dst_br);
 };
 
 
+class SphericalWarperGpu : public SphericalWarper
+{
+public:
+    SphericalWarperGpu(float scale = 300.f) : SphericalWarper(scale) {}
+    cv::Point warp(const cv::Mat &src, float focal, const cv::Mat &R, cv::Mat &dst,
+                   int interp_mode, int border_mode);
+
+private:
+    cv::gpu::GpuMat d_xmap_, d_ymap_, d_dst_;
+};
+
+
 struct CylindricalProjector : ProjectorBase
 {
     void mapForward(float x, float y, float &u, float &v);
@@ -147,13 +170,25 @@ class CylindricalWarper : public WarperBase<CylindricalProjector>
 public:
     CylindricalWarper(float scale = 300.f) { projector_.scale = scale; }
 
-private:
+protected:
     void detectResultRoi(cv::Point &dst_tl, cv::Point &dst_br)
     {
         WarperBase<CylindricalProjector>::detectResultRoiByBorder(dst_tl, dst_br);
     }
 };
 
+
+class CylindricalWarperGpu : public CylindricalWarper
+{
+public:
+    CylindricalWarperGpu(float scale = 300.f) : CylindricalWarper(scale) {}
+    cv::Point warp(const cv::Mat &src, float focal, const cv::Mat &R, cv::Mat &dst,
+                   int interp_mode, int border_mode);
+
+private:
+    cv::gpu::GpuMat d_xmap_, d_ymap_, d_dst_;
+};
+
 #include "warpers_inl.hpp"
 
 #endif // __OPENCV_WARPERS_HPP__
diff --git a/modules/traincascade/CMakeLists.txt b/modules/traincascade/CMakeLists.txt
index ebc6c84d7b..21d968a774 100644
--- a/modules/traincascade/CMakeLists.txt
+++ b/modules/traincascade/CMakeLists.txt
@@ -41,4 +41,6 @@ endif()
 
 target_link_libraries(${the_target} ${traincascade_libs})
 
-install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
+if(NOT ANDROID)
+    install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
+endif()
diff --git a/modules/ts/src/ts_arrtest.cpp b/modules/ts/src/ts_arrtest.cpp
index 7e340ded38..fe50e4ab90 100644
--- a/modules/ts/src/ts_arrtest.cpp
+++ b/modules/ts/src/ts_arrtest.cpp
@@ -216,7 +216,7 @@ int ArrayTest::prepare_test_case( int test_case_idx )
             CvArr* arr = test_array[i][j];
             test_mat[i][j] = cv::cvarrToMat(arr);
             if( !test_mat[i][j].empty() )
-                fill_array( test_case_idx, i, j, test_mat[i][j] );
+                fill_array( test_case_idx, (int)i, (int)j, test_mat[i][j] );
         }
     }
 
@@ -304,7 +304,7 @@ int ArrayTest::validate_test_results( int test_case_idx )
             if( !test_array[i1][j] )
                 continue;
 
-            err_level = get_success_error_level( test_case_idx, i0, j );
+            err_level = get_success_error_level( test_case_idx, i0, (int)j );
             code = cmpEps( test_mat[i0][j], test_mat[i1][j], &max_diff, err_level, &idx, element_wise_relative_error );
 
             switch( code )
diff --git a/modules/ts/src/ts_func.cpp b/modules/ts/src/ts_func.cpp
index 3d829de655..2675aab573 100644
--- a/modules/ts/src/ts_func.cpp
+++ b/modules/ts/src/ts_func.cpp
@@ -177,11 +177,12 @@ void add(const Mat& _a, double alpha, const Mat& _b, double beta,
     Mat planes[3], buf[3];
     
     NAryMatIterator it(arrays, planes);
-    int i, nplanes = it.nplanes, cn=a.channels();
-    size_t total = planes[0].total(), maxsize = std::min((size_t)12*12*std::max(12/cn, 1), total);
+    size_t i, nplanes = it.nplanes;
+	int cn=a.channels();
+    int total = (int)planes[0].total(), maxsize = std::min(12*12*std::max(12/cn, 1), total);
     
     CV_Assert(planes[0].rows == 1);
-    buf[0].create(1, (int)maxsize, CV_64FC(cn));
+    buf[0].create(1, maxsize, CV_64FC(cn));
     if(!b.empty())
         buf[1].create(1, maxsize, CV_64FC(cn));
     buf[2].create(1, maxsize, CV_64FC(cn));
@@ -189,12 +190,12 @@ void add(const Mat& _a, double alpha, const Mat& _b, double beta,
     
     for( i = 0; i < nplanes; i++, ++it)
     {
-        for( size_t j = 0; j < total; j += maxsize )
+        for( int j = 0; j < total; j += maxsize )
         {
-            size_t j2 = std::min(j + maxsize, total);
-            Mat apart0 = planes[0].colRange((int)j, (int)j2);
-            Mat cpart0 = planes[2].colRange((int)j, (int)j2);
-            Mat apart = buf[0].colRange(0, (int)(j2 - j));
+            int j2 = std::min(j + maxsize, total);
+            Mat apart0 = planes[0].colRange(j, j2);
+            Mat cpart0 = planes[2].colRange(j, j2);
+            Mat apart = buf[0].colRange(0, j2 - j);
             
             apart0.convertTo(apart, apart.type(), alpha);
             size_t k, n = (j2 - j)*cn;
@@ -291,7 +292,7 @@ void convert(const Mat& src, Mat& dst, int dtype, double alpha, double beta)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     
     for( i = 0; i < nplanes; i++, ++it)
     {
@@ -335,7 +336,7 @@ void copy(const Mat& src, Mat& dst, const Mat& mask, bool invertMask)
         const Mat* arrays[] = {&src, &dst, 0};
         Mat planes[2];
         NAryMatIterator it(arrays, planes);
-        int i, nplanes = it.nplanes;
+        size_t i, nplanes = it.nplanes;
         size_t planeSize = planes[0].total()*src.elemSize();
         
         for( i = 0; i < nplanes; i++, ++it )
@@ -351,7 +352,7 @@ void copy(const Mat& src, Mat& dst, const Mat& mask, bool invertMask)
     
     NAryMatIterator it(arrays, planes);
     size_t j, k, elemSize = src.elemSize(), total = planes[0].total();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     
     for( i = 0; i < nplanes; i++, ++it)
     {
@@ -380,7 +381,7 @@ void set(Mat& dst, const Scalar& gamma, const Mat& mask)
         const Mat* arrays[] = {&dst, 0};
         Mat plane;
         NAryMatIterator it(arrays, &plane);
-        int i, nplanes = it.nplanes;
+        size_t i, nplanes = it.nplanes;
         size_t j, k, elemSize = dst.elemSize(), planeSize = plane.total()*elemSize;
         
         for( k = 1; k < elemSize; k++ )
@@ -412,7 +413,7 @@ void set(Mat& dst, const Scalar& gamma, const Mat& mask)
     
     NAryMatIterator it(arrays, planes);
     size_t j, k, elemSize = dst.elemSize(), total = planes[0].total();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     
     for( i = 0; i < nplanes; i++, ++it)
     {
@@ -437,7 +438,7 @@ void insert(const Mat& src, Mat& dst, int coi)
     const Mat* arrays[] = {&src, &dst, 0};
     Mat planes[2];
     NAryMatIterator it(arrays, planes);
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     size_t j, k, size0 = src.elemSize(), size1 = dst.elemSize(), total = planes[0].total();
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -462,7 +463,7 @@ void extract(const Mat& src, Mat& dst, int coi)
     const Mat* arrays[] = {&src, &dst, 0};
     Mat planes[2];
     NAryMatIterator it(arrays, planes);
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     size_t j, k, size0 = src.elemSize(), size1 = dst.elemSize(), total = planes[0].total();
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -546,7 +547,8 @@ void randUni( RNG& rng, Mat& a, const Scalar& param0, const Scalar& param1 )
     Mat plane;
     
     NAryMatIterator it(arrays, &plane);
-    int i, nplanes = it.nplanes, depth = a.depth(), cn = a.channels();
+    size_t i, nplanes = it.nplanes;
+	int depth = a.depth(), cn = a.channels();
     size_t total = plane.total()*cn;
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1017,7 +1019,7 @@ static void setpos( const Mat& mtx, vector<int>& pos, size_t idx )
         for( int i = mtx.dims-1; i >= 0; i-- )
         {
             int sz = mtx.size[i]*(i == mtx.dims-1 ? mtx.channels() : 1);
-            pos[i] = idx % sz;
+            pos[i] = (int)(idx % sz);
             idx /= sz;
         }
     }
@@ -1038,7 +1040,8 @@ void minMaxLoc(const Mat& src, double* _minval, double* _maxval,
     
     NAryMatIterator it(arrays, planes);
     size_t startidx = 1, total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth();
     double maxval = depth < CV_32F ? INT_MIN : depth == CV_32F ? -FLT_MAX : -DBL_MAX;
     double minval = depth < CV_32F ? INT_MAX : depth == CV_32F ? FLT_MAX : DBL_MAX;
     size_t maxidx = 0, minidx = 0;
@@ -1220,8 +1223,8 @@ double norm(const Mat& src, int normType, const Mat& mask)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth();
-    int cn = planes[0].channels();
+    size_t i, nplanes = it.nplanes;
+    int depth = src.depth(), cn = planes[0].channels();
     double result = 0;
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1272,8 +1275,8 @@ double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src1.depth();
-    int cn = planes[0].channels();
+    size_t i, nplanes = it.nplanes;
+	int depth = src1.depth(), cn = planes[0].channels();
     double result = 0;
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1332,7 +1335,8 @@ double crossCorr(const Mat& src1, const Mat& src2)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels();
-    int i, nplanes = it.nplanes, depth = src1.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src1.depth();
     double result = 0;
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1394,14 +1398,14 @@ logicOpS_(const uchar* src, const uchar* scalar, uchar* dst, size_t total, char
     if( c == '&' )
         for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
         {
-            size_t sz = std::min(total - i, blockSize);
+            size_t sz = MIN(total - i, blockSize);
             for( j = 0; j < sz; j++ )
                 dst[j] = src[j] & scalar[j];
         }
     else if( c == '|' )
         for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
         {
-            size_t sz = std::min(total - i, blockSize);
+            size_t sz = MIN(total - i, blockSize);
             for( j = 0; j < sz; j++ )
                 dst[j] = src[j] | scalar[j];
         }
@@ -1409,7 +1413,7 @@ logicOpS_(const uchar* src, const uchar* scalar, uchar* dst, size_t total, char
     {
         for( i = 0; i < total; i += blockSize, dst += blockSize, src += blockSize )
         {
-            size_t sz = std::min(total - i, blockSize);
+            size_t sz = MIN(total - i, blockSize);
             for( j = 0; j < sz; j++ )
                 dst[j] = src[j] ^ scalar[j];
         }
@@ -1430,7 +1434,7 @@ void logicOp( const Mat& src1, const Mat& src2, Mat& dst, char op )
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].elemSize();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -1452,9 +1456,9 @@ void logicOp(const Mat& src, const Scalar& s, Mat& dst, char op)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].elemSize();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     double buf[12];
-    scalarToRawData(s, buf, src.type(), 96/planes[0].elemSize1());
+    scalarToRawData(s, buf, src.type(), (int)(96/planes[0].elemSize1()));
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -1547,7 +1551,8 @@ void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src1.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src1.depth();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -1593,7 +1598,8 @@ void compare(const Mat& src, double value, Mat& dst, int cmpop)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src.depth();
     int ivalue = saturate_cast<int>(value);
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -1721,7 +1727,8 @@ bool cmpUlps(const Mat& src1, const Mat& src2, int imaxDiff, double* _realmaxdif
     Mat planes[2];
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels();
-    int i, nplanes = it.nplanes, depth = src1.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = src1.depth();
     size_t startidx = 1, idx = 0;
     if(_realmaxdiff)
         *_realmaxdiff = 0;
@@ -1806,7 +1813,8 @@ int check( const Mat& a, double fmin, double fmax, vector<int>* _idx )
     Mat plane;
     NAryMatIterator it(arrays, &plane);
     size_t total = plane.total()*plane.channels();
-    int i, nplanes = it.nplanes, depth = a.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = a.depth();
     size_t startidx = 1, idx = 0;
     int imin = 0, imax = 0;
     
@@ -1874,7 +1882,8 @@ int cmpEps( const Mat& arr, const Mat& refarr, double* _realmaxdiff,
     Mat planes[2];
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels(), j = total;
-    int i, nplanes = it.nplanes, depth = arr.depth();
+    size_t i, nplanes = it.nplanes;
+	int depth = arr.depth();
     size_t startidx = 1, idx = 0;
     double realmaxdiff = 0, maxval = 0;
     
@@ -2160,11 +2169,11 @@ void gemm( const Mat& _a, const Mat& _b, double alpha,
     if( a.depth() == CV_32F )
         GEMM_(a.ptr<float>(), a_step, a_delta, b.ptr<float>(), b_step, b_delta,
               !c.empty() ? c.ptr<float>() : 0, c_step, c_delta, d.ptr<float>(),
-              d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
+              (int)d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
     else
         GEMM_(a.ptr<double>(), a_step, a_delta, b.ptr<double>(), b_step, b_delta,
               !c.empty() ? c.ptr<double>() : 0, c_step, c_delta, d.ptr<double>(),
-              d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
+              (int)d.step1(), a_rows, b_cols, a_cols, cn, alpha, beta );
 }
 
 
@@ -2282,7 +2291,7 @@ void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& _shift
     Mat planes[2];
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes;
+    size_t i, nplanes = it.nplanes;
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -2338,7 +2347,7 @@ static void minmax(const Mat& src1, const Mat& src2, Mat& dst, char op)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels();
-    int i, nplanes = it.nplanes, depth = src1.depth();
+    size_t i, nplanes = it.nplanes, depth = src1.depth();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -2406,7 +2415,7 @@ static void minmax(const Mat& src1, double val, Mat& dst, char op)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total()*planes[0].channels();
-    int i, nplanes = it.nplanes, depth = src1.depth();
+    size_t i, nplanes = it.nplanes, depth = src1.depth();
     int ival = saturate_cast<int>(val);
     
     for( i = 0; i < nplanes; i++, ++it )
@@ -2478,7 +2487,7 @@ static void muldiv(const Mat& src1, const Mat& src2, Mat& dst, double scale, cha
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[1].total()*planes[1].channels();
-    int i, nplanes = it.nplanes, depth = src2.depth();
+    size_t i, nplanes = it.nplanes, depth = src2.depth();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
@@ -2563,7 +2572,8 @@ Scalar mean(const Mat& src, const Mat& mask)
     
     NAryMatIterator it(arrays, planes);
     size_t total = planes[0].total();
-    int i, nplanes = it.nplanes, depth = src.depth(), cn = src.channels();
+    size_t i, nplanes = it.nplanes;
+    int depth = src.depth(), cn = src.channels();
     
     for( i = 0; i < nplanes; i++, ++it )
     {
diff --git a/modules/video/doc/motion_analysis_and_object_tracking.rst b/modules/video/doc/motion_analysis_and_object_tracking.rst
index e06c459ca0..13cd9bb907 100644
--- a/modules/video/doc/motion_analysis_and_object_tracking.rst
+++ b/modules/video/doc/motion_analysis_and_object_tracking.rst
@@ -33,8 +33,8 @@ Calculates an optical flow for a sparse feature set using the iterative Lucas-Ka
     :param maxLevel: 0-based maximal pyramid level number. If set to 0, pyramids are not used (single level). If set to 1, two levels are used, and so on.
 
     :param criteria: Parameter specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations  ``criteria.maxCount``  or when the search window moves by less than  ``criteria.epsilon`` .
-	
-    :param derivLambda: Relative weight of the spatial image derivatives impact to the optical flow estimation. If  ``derivLambda=0`` , only the image intensity is used. If  ``derivLambda=1`` , only derivatives are used. Any other values between 0 and 1 mean that both derivatives and the image intensity are used (in the corresponding proportions).
+    
+    :param derivLambda: Not used.
 
     :param flags: Operation flags:
 
@@ -51,7 +51,9 @@ Computes a dense optical flow using the Gunnar Farneback's algorithm.
 
 .. ocv:function:: void calcOpticalFlowFarneback( InputArray prevImg, InputArray nextImg,                               InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags )
 
-.. ocv:pyfunction:: cv2.calcOpticalFlowFarneback(prev, next, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags[, flow]) -> flow
+.. ocv:cfunction:: void cvCalcOpticalFlowFarneback( const CvArr* prevImg, const CvArr* nextImg, CvArr* flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags )
+
+.. ocv:pyfunction:: cv2.calcOpticalFlowFarneback(prevImg, nextImg, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags[, flow]) -> flow
 
     :param prevImg: First 8-bit single-channel input image.
 
@@ -70,7 +72,7 @@ Computes a dense optical flow using the Gunnar Farneback's algorithm.
     :param polyN: Size of the pixel neighborhood used to find polynomial expansion in each pixel. Larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred  motion field. Typically,  ``polyN`` =5 or 7.
 
     :param polySigma: Standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion. For  ``polyN=5`` ,  you can set  ``polySigma=1.1`` . For  ``polyN=7`` , a good value would be  ``polySigma=1.5`` .
-	
+    
     :param flags: Operation flags that can be a combination of the following:
 
             * **OPTFLOW_USE_INITIAL_FLOW** Use the input  ``flow``  as an initial flow approximation.
@@ -322,7 +324,7 @@ Splits a motion history image into a few parts corresponding to separate indepen
 
 .. ocv:function:: void segmentMotion(InputArray mhi, OutputArray segmask, vector<Rect>& boundingRects, double timestamp, double segThresh)
 
-.. ocv:pyfunction:: cv2.segmentMotion(mhi, boundingRects, timestamp, segThresh[, segmask]) -> segmask
+.. ocv:pyfunction:: cv2.segmentMotion(mhi, timestamp, segThresh[, segmask]) -> segmask, boundingRects
 
 .. ocv:cfunction:: CvSeq* cvSegmentMotion( const CvArr* mhi, CvArr* segMask, CvMemStorage* storage, double timestamp, double segThresh )
 .. ocv:pyoldfunction:: cv.SegmentMotion(mhi, segMask, storage, timestamp, segThresh)-> None
@@ -382,7 +384,7 @@ Finds an object on a back projection image.
 .. ocv:pyoldfunction:: cv.MeanShift(probImage, window, criteria)-> comp
 
     :param probImage: Back projection of the object histogram. See  :ocv:func:`calcBackProject` for details.
-	
+    
     :param window: Initial search window.
 
     :param criteria: Stop criteria for the iterative search algorithm.
@@ -480,7 +482,7 @@ Updates the predicted state from the measurement.
 BackgroundSubtractor
 --------------------
 
-.. ocv:class: BackgroundSubtractor
+.. ocv:class:: BackgroundSubtractor
 
 Base class for background/foreground segmentation. ::
 
@@ -522,7 +524,7 @@ Computes a background image.
 BackgroundSubtractorMOG
 -----------------------
 
-.. ocv:class: BackgroundSubtractorMOG : public BackgroundSubtractor
+.. ocv:class:: BackgroundSubtractorMOG : public BackgroundSubtractor
 
 Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm.
 
@@ -567,7 +569,7 @@ BackgroundSubtractorMOG2
 ------------------------
 Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm.
 
-.. ocv:class: BackgroundSubtractorMOG2 : public BackgroundSubtractor
+.. ocv:class:: BackgroundSubtractorMOG2 : public BackgroundSubtractor
 
     Here are important members of the class that control the algorithm, which you can set after constructing the class instance:
 
diff --git a/modules/video/include/opencv2/video/tracking.hpp b/modules/video/include/opencv2/video/tracking.hpp
index bcf969c88b..53b84636f7 100644
--- a/modules/video/include/opencv2/video/tracking.hpp
+++ b/modules/video/include/opencv2/video/tracking.hpp
@@ -259,15 +259,15 @@ CV_EXPORTS_W double calcGlobalOrientation( InputArray orientation, InputArray ma
                                            double duration );
 
 CV_EXPORTS_W void segmentMotion(InputArray mhi, OutputArray segmask,
-                                vector<Rect>& boundingRects,
+                                CV_OUT vector<Rect>& boundingRects,
                                 double timestamp, double segThresh);
 
 //! updates the object tracking window using CAMSHIFT algorithm
-CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_IN_OUT Rect& window,
+CV_EXPORTS_W RotatedRect CamShift( InputArray probImage, CV_OUT CV_IN_OUT Rect& window,
                                    TermCriteria criteria );
 
 //! updates the object tracking window using meanshift algorithm
-CV_EXPORTS_W int meanShift( InputArray probImage, CV_IN_OUT Rect& window,
+CV_EXPORTS_W int meanShift( InputArray probImage, CV_OUT CV_IN_OUT Rect& window,
                             TermCriteria criteria );
 
 /*!
@@ -318,12 +318,13 @@ enum { OPTFLOW_USE_INITIAL_FLOW=4, OPTFLOW_FARNEBACK_GAUSSIAN=256 };
 CV_EXPORTS_W void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg,
                            InputArray prevPts, CV_OUT InputOutputArray nextPts,
                            OutputArray status, OutputArray err,
-                           Size winSize=Size(15,15), int maxLevel=3,
+                           Size winSize=Size(21,21), int maxLevel=3,
                            TermCriteria criteria=TermCriteria(
                             TermCriteria::COUNT+TermCriteria::EPS,
                             30, 0.01),
                            double derivLambda=0.5,
-                           int flags=0 );
+                           int flags=0,
+                           double minEigThreshold=1e-4);
 
 //! computes dense optical flow using Farneback algorithm
 CV_EXPORTS_W void calcOpticalFlowFarneback( InputArray prev, InputArray next,
diff --git a/modules/gpu/test/test_operator_async_call.cpp b/modules/video/include/opencv2/video/video.hpp
similarity index 57%
rename from modules/gpu/test/test_operator_async_call.cpp
rename to modules/video/include/opencv2/video/video.hpp
index 34843c79de..21a2fcec4f 100644
--- a/modules/gpu/test/test_operator_async_call.cpp
+++ b/modules/video/include/opencv2/video/video.hpp
@@ -7,10 +7,11 @@
 //  copy or use the software.
 //
 //
-//                        Intel License Agreement
+//                           License Agreement
 //                For Open Source Computer Vision Library
 //
-// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// 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,
@@ -23,7 +24,7 @@
 //     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
+//   * 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
@@ -39,46 +40,10 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#ifndef __OPENCV_VIDEO_HPP__
+#define __OPENCV_VIDEO_HPP__
 
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/video/background_segm.hpp"
 
-struct CV_AsyncGpuMatTest : public cvtest::BaseTest
-{
-    CV_AsyncGpuMatTest() {}
-
-    void run(int)
-    {
-        CudaMem src(Mat::zeros(100, 100, CV_8UC1));
-
-        GpuMat gpusrc;
-        GpuMat gpudst0, gpudst1(100, 100, CV_8UC1);
-
-        CudaMem cpudst0;
-        CudaMem cpudst1;
-
-        Stream stream0, stream1;
-
-        stream0.enqueueUpload(src, gpusrc);
-        bitwise_not(gpusrc, gpudst0, GpuMat(), stream0);
-        stream0.enqueueDownload(gpudst0, cpudst0);
-
-        stream1.enqueueMemSet(gpudst1, Scalar::all(128));
-        stream1.enqueueDownload(gpudst1, cpudst1);
-
-        stream0.waitForCompletion();
-        stream1.waitForCompletion();
-
-        Mat cpu_gold0(100, 100, CV_8UC1, Scalar::all(255));
-        Mat cpu_gold1(100, 100, CV_8UC1, Scalar::all(128));
-
-        if (norm((Mat)cpudst0, cpu_gold0, NORM_INF) > 0 || norm((Mat)cpudst1, cpu_gold1, NORM_INF) > 0)
-            ts->set_failed_test_info(cvtest::TS::FAIL_GENERIC);
-        else
-            ts->set_failed_test_info(cvtest::TS::OK);
-    }
-};
-
-TEST(GpuMat, async) { CV_AsyncGpuMatTest test; test.safe_run(); }
+#endif //__OPENCV_VIDEO_HPP__
diff --git a/modules/video/src/bgfg_gaussmix2.cpp b/modules/video/src/bgfg_gaussmix2.cpp
index 1d1f0c8f81..65d646cca6 100644
--- a/modules/video/src/bgfg_gaussmix2.cpp
+++ b/modules/video/src/bgfg_gaussmix2.cpp
@@ -204,69 +204,68 @@ typedef struct CvGaussBGModel2
     CvGaussBGStatModel2Params params;
     CvGaussBGStatModel2Data   data;
     int                       countFrames;
-}
-CvGaussBGModel2;
+} CvGaussBGModel2;
 
 CVAPI(CvBGStatModel*) cvCreateGaussianBGModel2( IplImage* first_frame,
                                                 CvGaussBGStatModel2Params* params CV_DEFAULT(NULL) );
 //shadow detection performed per pixel
 // should work for rgb data, could be usefull for gray scale and depth data as well
-//	See: Prati,Mikic,Trivedi,Cucchiarra,"Detecting Moving Shadows...",IEEE PAMI,2003.
+//  See: Prati,Mikic,Trivedi,Cucchiarra,"Detecting Moving Shadows...",IEEE PAMI,2003.
 CV_INLINE int _icvRemoveShadowGMM(float* data, int nD,
-								unsigned char nModes, 
-								CvPBGMMGaussian* pGMM,
-								float m_fTb,
-								float m_fTB,	
-								float m_fTau)
+                                unsigned char nModes, 
+                                CvPBGMMGaussian* pGMM,
+                                float m_fTb,
+                                float m_fTB,    
+                                float m_fTau)
 {
-	float tWeight = 0;
-	float numerator, denominator;
-	// check all the components  marked as background:
-	for (int iModes=0;iModes<nModes;iModes++)
-	{
+    float tWeight = 0;
+    float numerator, denominator;
+    // check all the components  marked as background:
+    for (int iModes=0;iModes<nModes;iModes++)
+    {
 
-		CvPBGMMGaussian g=pGMM[iModes];
+        CvPBGMMGaussian g=pGMM[iModes];
 
-		numerator = 0.0f;
-		denominator = 0.0f;
-		for (int iD=0;iD<nD;iD++)
-		{
-				numerator   += data[iD]  * g.mean[iD];
-				denominator += g.mean[iD]* g.mean[iD];
-		}
+        numerator = 0.0f;
+        denominator = 0.0f;
+        for (int iD=0;iD<nD;iD++)
+        {
+                numerator   += data[iD]  * g.mean[iD];
+                denominator += g.mean[iD]* g.mean[iD];
+        }
 
-		// no division by zero allowed
-		if (denominator == 0)
-		{
-				return 0;
-		};
-		float a = numerator / denominator;
+        // no division by zero allowed
+        if (denominator == 0)
+        {
+                return 0;
+        };
+        float a = numerator / denominator;
 
-		// if tau < a < 1 then also check the color distortion
-		if ((a <= 1) && (a >= m_fTau))
-		{
+        // if tau < a < 1 then also check the color distortion
+        if ((a <= 1) && (a >= m_fTau))
+        {
 
-			float dist2a=0.0f;
-			
-			for (int iD=0;iD<nD;iD++)
-			{
-				float dD= a*g.mean[iD] - data[iD];
-				dist2a += (dD*dD);
-			}
+            float dist2a=0.0f;
+            
+            for (int iD=0;iD<nD;iD++)
+            {
+                float dD= a*g.mean[iD] - data[iD];
+                dist2a += (dD*dD);
+            }
 
-			if (dist2a<m_fTb*g.variance*a*a)
-			{
-				return 2;
-			}
-		};
+            if (dist2a<m_fTb*g.variance*a*a)
+            {
+                return 2;
+            }
+        };
 
-		tWeight += g.weight;
-		if (tWeight > m_fTB)
-		{
-				return 0;
-		};
-	};
-	return 0;
+        tWeight += g.weight;
+        if (tWeight > m_fTB)
+        {
+                return 0;
+        };
+    };
+    return 0;
 }
 
 //update GMM - the base update function performed per pixel
@@ -284,402 +283,402 @@ CV_INLINE int _icvRemoveShadowGMM(float* data, int nD,
 //http://www.zoranz.net/Publications/zivkovic2004PAMI.pdf
 
 CV_INLINE int _icvUpdateGMM(float* data, int nD,
-								unsigned char* pModesUsed, 
-								CvPBGMMGaussian* pGMM,
-								int m_nM,
-								float m_fAlphaT,
-								float m_fTb,
-								float m_fTB,	
-								float m_fTg,
-								float m_fVarInit,
-								float m_fVarMax,
-								float m_fVarMin,
-								float m_fPrune)
+                                unsigned char* pModesUsed, 
+                                CvPBGMMGaussian* pGMM,
+                                int m_nM,
+                                float m_fAlphaT,
+                                float m_fTb,
+                                float m_fTB,    
+                                float m_fTg,
+                                float m_fVarInit,
+                                float m_fVarMax,
+                                float m_fVarMin,
+                                float m_fPrune)
 {
-	//calculate distances to the modes (+ sort)
-	//here we need to go in descending order!!!	
-	bool bBackground=0;//return value -> true - the pixel classified as background
+    //calculate distances to the modes (+ sort)
+    //here we need to go in descending order!!! 
+    bool bBackground=0;//return value -> true - the pixel classified as background
 
-	//internal:
-	bool bFitsPDF=0;//if it remains zero a new GMM mode will be added	
-	float m_fOneMinAlpha=1-m_fAlphaT;
-	unsigned char nModes=*pModesUsed;//current number of modes in GMM
-	float totalWeight=0.0f;
+    //internal:
+    bool bFitsPDF=0;//if it remains zero a new GMM mode will be added   
+    float m_fOneMinAlpha=1-m_fAlphaT;
+    unsigned char nModes=*pModesUsed;//current number of modes in GMM
+    float totalWeight=0.0f;
 
-	//////
-	//go through all modes
-	int iMode=0;
-	CvPBGMMGaussian* pGauss=pGMM;
-	for (;iMode<nModes;iMode++,pGauss++)
-	{
-		float weight = pGauss->weight;//need only weight if fit is found
-		weight=m_fOneMinAlpha*weight+m_fPrune;
+    //////
+    //go through all modes
+    int iMode=0;
+    CvPBGMMGaussian* pGauss=pGMM;
+    for (;iMode<nModes;iMode++,pGauss++)
+    {
+        float weight = pGauss->weight;//need only weight if fit is found
+        weight=m_fOneMinAlpha*weight+m_fPrune;
 
-		////
-		//fit not found yet
-		if (!bFitsPDF)
-		{
-			//check if it belongs to some of the remaining modes
-			float var=pGauss->variance;
+        ////
+        //fit not found yet
+        if (!bFitsPDF)
+        {
+            //check if it belongs to some of the remaining modes
+            float var=pGauss->variance;
 
-			//calculate difference and distance
-			float dist2=0.0f;
+            //calculate difference and distance
+            float dist2=0.0f;
 #if (CV_BGFG_MOG2_NDMAX==1)
-			float dData=pGauss->mean[0]-data[0];
-			dist2=dData*dData;
-#else			
-			float dData[CV_BGFG_MOG2_NDMAX];
+            float dData=pGauss->mean[0]-data[0];
+            dist2=dData*dData;
+#else           
+            float dData[CV_BGFG_MOG2_NDMAX];
 
-			for (int iD=0;iD<nD;iD++)
-			{
-				dData[iD]=pGauss->mean[iD]-data[iD];
-				dist2+=dData[iD]*dData[iD];
-			}
-#endif		
-			//background? - m_fTb - usually larger than m_fTg
-			if ((totalWeight<m_fTB)&&(dist2<m_fTb*var))
-					bBackground=1;
+            for (int iD=0;iD<nD;iD++)
+            {
+                dData[iD]=pGauss->mean[iD]-data[iD];
+                dist2+=dData[iD]*dData[iD];
+            }
+#endif      
+            //background? - m_fTb - usually larger than m_fTg
+            if ((totalWeight<m_fTB)&&(dist2<m_fTb*var))
+                    bBackground=1;
 
-			//check fit
-			if (dist2<m_fTg*var)
-			{
-				/////
-				//belongs to the mode - bFitsPDF becomes 1
-				bFitsPDF=1;
+            //check fit
+            if (dist2<m_fTg*var)
+            {
+                /////
+                //belongs to the mode - bFitsPDF becomes 1
+                bFitsPDF=1;
 
-				//update distribution				
-				
-				//update weight
-				weight+=m_fAlphaT;
+                //update distribution               
+                
+                //update weight
+                weight+=m_fAlphaT;
 
-				float k = m_fAlphaT/weight;
+                float k = m_fAlphaT/weight;
 
-				//update mean
+                //update mean
 #if (CV_BGFG_MOG2_NDMAX==1)
-				pGauss->mean[0]-=k*dData;
-#else				
-				for (int iD=0;iD<nD;iD++)
-				{
-					pGauss->mean[iD]-=k*dData[iD];
-				}
+                pGauss->mean[0]-=k*dData;
+#else               
+                for (int iD=0;iD<nD;iD++)
+                {
+                    pGauss->mean[iD]-=k*dData[iD];
+                }
 #endif
 
-				//update variance
-				float varnew = var + k*(dist2-var);
-				//limit the variance				
-				pGauss->variance = MIN(m_fVarMax,MAX(varnew,m_fVarMin));
+                //update variance
+                float varnew = var + k*(dist2-var);
+                //limit the variance                
+                pGauss->variance = MIN(m_fVarMax,MAX(varnew,m_fVarMin));
 
-				//sort
-				//all other weights are at the same place and 
-				//only the matched (iModes) is higher -> just find the new place for it				
-				for (int iLocal = iMode;iLocal>0;iLocal--)
-				{
-					//check one up
-					if (weight < (pGMM[iLocal-1].weight))
-					{
-						break;
-					}
-					else
-					{
-						//swap one up
-						CvPBGMMGaussian temp = pGMM[iLocal];
-						pGMM[iLocal] = pGMM[iLocal-1];
-						pGMM[iLocal-1] = temp;
-						pGauss--;
-					}
-				}
-				//belongs to the mode - bFitsPDF becomes 1
-				/////
-			}
-		}//!bFitsPDF)
+                //sort
+                //all other weights are at the same place and 
+                //only the matched (iModes) is higher -> just find the new place for it             
+                for (int iLocal = iMode;iLocal>0;iLocal--)
+                {
+                    //check one up
+                    if (weight < (pGMM[iLocal-1].weight))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        //swap one up
+                        CvPBGMMGaussian temp = pGMM[iLocal];
+                        pGMM[iLocal] = pGMM[iLocal-1];
+                        pGMM[iLocal-1] = temp;
+                        pGauss--;
+                    }
+                }
+                //belongs to the mode - bFitsPDF becomes 1
+                /////
+            }
+        }//!bFitsPDF)
 
-		//check prune
-		if (weight<-m_fPrune)
-		{
-			weight=0.0;
-			nModes--;
-		}
+        //check prune
+        if (weight<-m_fPrune)
+        {
+            weight=0.0;
+            nModes--;
+        }
 
-		pGauss->weight=weight;//update weight by the calculated value
-		totalWeight+=weight;
-	}
-	//go through all modes
-	//////
+        pGauss->weight=weight;//update weight by the calculated value
+        totalWeight+=weight;
+    }
+    //go through all modes
+    //////
 
-	//renormalize weights
-	for (iMode = 0; iMode < nModes; iMode++)
-	{
-		pGMM[iMode].weight = pGMM[iMode].weight/totalWeight;
-	}
-	
-	//make new mode if needed and exit
-	if (!bFitsPDF)
-	{
-		if (nModes==m_nM)
-		{
+    //renormalize weights
+    for (iMode = 0; iMode < nModes; iMode++)
+    {
+        pGMM[iMode].weight = pGMM[iMode].weight/totalWeight;
+    }
+    
+    //make new mode if needed and exit
+    if (!bFitsPDF)
+    {
+        if (nModes==m_nM)
+        {
            //replace the weakest
-			pGauss=pGMM+m_nM-1;
-		}
-		else
-		{
+            pGauss=pGMM+m_nM-1;
+        }
+        else
+        {
            //add a new one
-			pGauss=pGMM+nModes;
-			nModes++;
-		}
+            pGauss=pGMM+nModes;
+            nModes++;
+        }
 
-      	if (nModes==1)
-		{
-			pGauss->weight=1;
-		}
-		else
-		{
-			pGauss->weight=m_fAlphaT;
+        if (nModes==1)
+        {
+            pGauss->weight=1;
+        }
+        else
+        {
+            pGauss->weight=m_fAlphaT;
 
-			//renormalize all weights
-			for (iMode = 0; iMode < nModes-1; iMode++)
-			{
-				pGMM[iMode].weight *=m_fOneMinAlpha;
-			}
-		}
+            //renormalize all weights
+            for (iMode = 0; iMode < nModes-1; iMode++)
+            {
+                pGMM[iMode].weight *=m_fOneMinAlpha;
+            }
+        }
 
-		//init 
-		memcpy(pGauss->mean,data,nD*sizeof(float));
-		pGauss->variance=m_fVarInit;
+        //init 
+        memcpy(pGauss->mean,data,nD*sizeof(float));
+        pGauss->variance=m_fVarInit;
 
-		//sort
-		//find the new place for it
-		for (int iLocal = nModes-1;iLocal>0;iLocal--)
-		{
-					//check one up
-					if (m_fAlphaT < (pGMM[iLocal-1].weight))
-					{
-						break;
-					}
-					else
-					{
-						//swap one up
-						CvPBGMMGaussian temp = pGMM[iLocal];
-						pGMM[iLocal] = pGMM[iLocal-1];
-						pGMM[iLocal-1] = temp;
-					}
-		}
-	}
+        //sort
+        //find the new place for it
+        for (int iLocal = nModes-1;iLocal>0;iLocal--)
+        {
+                    //check one up
+                    if (m_fAlphaT < (pGMM[iLocal-1].weight))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        //swap one up
+                        CvPBGMMGaussian temp = pGMM[iLocal];
+                        pGMM[iLocal] = pGMM[iLocal-1];
+                        pGMM[iLocal-1] = temp;
+                    }
+        }
+    }
 
-	//set the number of modes
-	*pModesUsed=nModes;
+    //set the number of modes
+    *pModesUsed=nModes;
 
     return bBackground;
 }
 
 // a bit more efficient implementation for common case of 3 channel (rgb) images
 CV_INLINE int _icvUpdateGMM_C3(float r,float g, float b,
-								unsigned char* pModesUsed, 
-								CvPBGMMGaussian* pGMM,
-								int m_nM,
-								float m_fAlphaT,
-								float m_fTb,
-								float m_fTB,	
-								float m_fTg,
-								float m_fVarInit,
-								float m_fVarMax,
-								float m_fVarMin,
-								float m_fPrune)
+                                unsigned char* pModesUsed, 
+                                CvPBGMMGaussian* pGMM,
+                                int m_nM,
+                                float m_fAlphaT,
+                                float m_fTb,
+                                float m_fTB,    
+                                float m_fTg,
+                                float m_fVarInit,
+                                float m_fVarMax,
+                                float m_fVarMin,
+                                float m_fPrune)
 {
-	//calculate distances to the modes (+ sort)
-	//here we need to go in descending order!!!	
-	bool bBackground=0;//return value -> true - the pixel classified as background
+    //calculate distances to the modes (+ sort)
+    //here we need to go in descending order!!! 
+    bool bBackground=0;//return value -> true - the pixel classified as background
 
-	//internal:
-	bool bFitsPDF=0;//if it remains zero a new GMM mode will be added	
-	float m_fOneMinAlpha=1-m_fAlphaT;
-	unsigned char nModes=*pModesUsed;//current number of modes in GMM
-	float totalWeight=0.0f;
+    //internal:
+    bool bFitsPDF=0;//if it remains zero a new GMM mode will be added   
+    float m_fOneMinAlpha=1-m_fAlphaT;
+    unsigned char nModes=*pModesUsed;//current number of modes in GMM
+    float totalWeight=0.0f;
 
-	//////
-	//go through all modes
-	int iMode=0;
-	CvPBGMMGaussian* pGauss=pGMM;
-	for (;iMode<nModes;iMode++,pGauss++)
-	{
-		float weight = pGauss->weight;//need only weight if fit is found
-		weight=m_fOneMinAlpha*weight+m_fPrune;
+    //////
+    //go through all modes
+    int iMode=0;
+    CvPBGMMGaussian* pGauss=pGMM;
+    for (;iMode<nModes;iMode++,pGauss++)
+    {
+        float weight = pGauss->weight;//need only weight if fit is found
+        weight=m_fOneMinAlpha*weight+m_fPrune;
 
-		////
-		//fit not found yet
-		if (!bFitsPDF)
-		{
-			//check if it belongs to some of the remaining modes
-			float var=pGauss->variance;
+        ////
+        //fit not found yet
+        if (!bFitsPDF)
+        {
+            //check if it belongs to some of the remaining modes
+            float var=pGauss->variance;
 
-			//calculate difference and distance
-			float muR = pGauss->mean[0];
-			float muG = pGauss->mean[1];
-			float muB = pGauss->mean[2];
-		
-			float dR=muR - r;
-			float dG=muG - g;
-			float dB=muB - b;
+            //calculate difference and distance
+            float muR = pGauss->mean[0];
+            float muG = pGauss->mean[1];
+            float muB = pGauss->mean[2];
+        
+            float dR=muR - r;
+            float dG=muG - g;
+            float dB=muB - b;
 
-			float dist2=(dR*dR+dG*dG+dB*dB);		
-			
-			//background? - m_fTb - usually larger than m_fTg
-			if ((totalWeight<m_fTB)&&(dist2<m_fTb*var))
-					bBackground=1;
+            float dist2=(dR*dR+dG*dG+dB*dB);        
+            
+            //background? - m_fTb - usually larger than m_fTg
+            if ((totalWeight<m_fTB)&&(dist2<m_fTb*var))
+                    bBackground=1;
 
-			//check fit
-			if (dist2<m_fTg*var)
-			{
-				/////
-				//belongs to the mode - bFitsPDF becomes 1
-				bFitsPDF=1;
+            //check fit
+            if (dist2<m_fTg*var)
+            {
+                /////
+                //belongs to the mode - bFitsPDF becomes 1
+                bFitsPDF=1;
 
-				//update distribution				
-				
-				//update weight
-				weight+=m_fAlphaT;
-				
-				float k = m_fAlphaT/weight;
+                //update distribution               
+                
+                //update weight
+                weight+=m_fAlphaT;
+                
+                float k = m_fAlphaT/weight;
 
-				//update mean
-				pGauss->mean[0] = muR - k*(dR);
-				pGauss->mean[1] = muG - k*(dG);
-				pGauss->mean[2] = muB - k*(dB);
+                //update mean
+                pGauss->mean[0] = muR - k*(dR);
+                pGauss->mean[1] = muG - k*(dG);
+                pGauss->mean[2] = muB - k*(dB);
 
-				//update variance
-				float varnew = var + k*(dist2-var);
-				//limit the variance				
-				pGauss->variance = MIN(m_fVarMax,MAX(varnew,m_fVarMin));
+                //update variance
+                float varnew = var + k*(dist2-var);
+                //limit the variance                
+                pGauss->variance = MIN(m_fVarMax,MAX(varnew,m_fVarMin));
 
-				//sort
-				//all other weights are at the same place and 
-				//only the matched (iModes) is higher -> just find the new place for it				
-				for (int iLocal = iMode;iLocal>0;iLocal--)
-				{
-					//check one up
-					if (weight < (pGMM[iLocal-1].weight))
-					{
-						break;
-					}
-					else
-					{
-						//swap one up
-						CvPBGMMGaussian temp = pGMM[iLocal];
-						pGMM[iLocal] = pGMM[iLocal-1];
-						pGMM[iLocal-1] = temp;
-						pGauss--;
-					}
-				}
-				//belongs to the mode - bFitsPDF becomes 1
-				/////
-			}	
+                //sort
+                //all other weights are at the same place and 
+                //only the matched (iModes) is higher -> just find the new place for it             
+                for (int iLocal = iMode;iLocal>0;iLocal--)
+                {
+                    //check one up
+                    if (weight < (pGMM[iLocal-1].weight))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        //swap one up
+                        CvPBGMMGaussian temp = pGMM[iLocal];
+                        pGMM[iLocal] = pGMM[iLocal-1];
+                        pGMM[iLocal-1] = temp;
+                        pGauss--;
+                    }
+                }
+                //belongs to the mode - bFitsPDF becomes 1
+                /////
+            }   
 
-		}//!bFitsPDF)
-		
-		//check prunning
-		if (weight<-m_fPrune)
-		{
-					weight=0.0;
-					nModes--;
-		}
+        }//!bFitsPDF)
+        
+        //check prunning
+        if (weight<-m_fPrune)
+        {
+                    weight=0.0;
+                    nModes--;
+        }
 
-		pGauss->weight=weight;
-		totalWeight+=weight;
-	}
-	//go through all modes
-	//////
+        pGauss->weight=weight;
+        totalWeight+=weight;
+    }
+    //go through all modes
+    //////
 
-	//renormalize weights
-	for (iMode = 0; iMode < nModes; iMode++)
-	{
-		pGMM[iMode].weight = pGMM[iMode].weight/totalWeight;
-	}
-	
-	//make new mode if needed and exit
-	if (!bFitsPDF)
-	{
-		if (nModes==m_nM)
-		{
+    //renormalize weights
+    for (iMode = 0; iMode < nModes; iMode++)
+    {
+        pGMM[iMode].weight = pGMM[iMode].weight/totalWeight;
+    }
+    
+    //make new mode if needed and exit
+    if (!bFitsPDF)
+    {
+        if (nModes==m_nM)
+        {
            //replace the weakest
-			pGauss=pGMM+m_nM-1;
-		}
-		else
-		{
+            pGauss=pGMM+m_nM-1;
+        }
+        else
+        {
            //add a new one
-			pGauss=pGMM+nModes;
-			nModes++;
-		}
+            pGauss=pGMM+nModes;
+            nModes++;
+        }
 
-      	if (nModes==1)
-		{
-			pGauss->weight=1;
-		}
-		else
-		{
-			pGauss->weight=m_fAlphaT;
+        if (nModes==1)
+        {
+            pGauss->weight=1;
+        }
+        else
+        {
+            pGauss->weight=m_fAlphaT;
 
-			//renormalize all weights
-			for (iMode = 0; iMode < nModes-1; iMode++)
-			{
-				pGMM[iMode].weight *=m_fOneMinAlpha;
-			}
-		}
+            //renormalize all weights
+            for (iMode = 0; iMode < nModes-1; iMode++)
+            {
+                pGMM[iMode].weight *=m_fOneMinAlpha;
+            }
+        }
 
-		//init 
-		pGauss->mean[0]=r;
-		pGauss->mean[1]=g;
-		pGauss->mean[2]=b;
+        //init 
+        pGauss->mean[0]=r;
+        pGauss->mean[1]=g;
+        pGauss->mean[2]=b;
 
-		pGauss->variance=m_fVarInit;
+        pGauss->variance=m_fVarInit;
 
-		//sort
-		//find the new place for it
-		for (int iLocal = nModes-1;iLocal>0;iLocal--)
-		{
-					//check one up
-					if (m_fAlphaT < (pGMM[iLocal-1].weight))
-					{
-						break;
-					}
-					else
-					{
-						//swap one up
-						CvPBGMMGaussian temp = pGMM[iLocal];
-						pGMM[iLocal] = pGMM[iLocal-1];
-						pGMM[iLocal-1] = temp;
-					}
-		}
-	}
+        //sort
+        //find the new place for it
+        for (int iLocal = nModes-1;iLocal>0;iLocal--)
+        {
+                    //check one up
+                    if (m_fAlphaT < (pGMM[iLocal-1].weight))
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        //swap one up
+                        CvPBGMMGaussian temp = pGMM[iLocal];
+                        pGMM[iLocal] = pGMM[iLocal-1];
+                        pGMM[iLocal-1] = temp;
+                    }
+        }
+    }
 
-	//set the number of modes
-	*pModesUsed=nModes;
+    //set the number of modes
+    *pModesUsed=nModes;
 
     return bBackground;
 }
 
 //the main function to update the background model
 void icvUpdatePixelBackgroundGMM2( const CvArr* srcarr, CvArr* dstarr ,
-										 CvPBGMMGaussian *pGMM,
-										 unsigned char *pUsedModes,
-										 //CvGaussBGStatModel2Params* pGMMPar,
-										 int nM,
-										 float fTb, 
-										 float fTB, 
-										 float fTg, 
-										 float fVarInit,
-										 float fVarMax,
-										 float fVarMin,
-										 float fCT,
-										 float fTau,
-										 bool bShadowDetection,
-										 unsigned char  nShadowDetection,
-										 float alpha)
+                                         CvPBGMMGaussian *pGMM,
+                                         unsigned char *pUsedModes,
+                                         //CvGaussBGStatModel2Params* pGMMPar,
+                                         int nM,
+                                         float fTb, 
+                                         float fTB, 
+                                         float fTg, 
+                                         float fVarInit,
+                                         float fVarMax,
+                                         float fVarMin,
+                                         float fCT,
+                                         float fTau,
+                                         bool bShadowDetection,
+                                         unsigned char  nShadowDetection,
+                                         float alpha)
 {
-	CvMat sstub, *src = cvGetMat(srcarr, &sstub);
+    CvMat sstub, *src = cvGetMat(srcarr, &sstub);
     CvMat dstub, *dst = cvGetMat(dstarr, &dstub);
     CvSize size = cvGetMatSize(src);
-	int nD=CV_MAT_CN(src->type);
+    int nD=CV_MAT_CN(src->type);
 
-	//reshape if possible
+    //reshape if possible
     if( CV_IS_MAT_CONT(src->type & dst->type) )
     {
         size.width *= size.height;
@@ -687,258 +686,258 @@ void icvUpdatePixelBackgroundGMM2( const CvArr* srcarr, CvArr* dstarr ,
     }
 
     int x, y;
-	float data[CV_BGFG_MOG2_NDMAX];
-	float prune=-alpha*fCT;
+    float data[CV_BGFG_MOG2_NDMAX];
+    float prune=-alpha*fCT;
 
-	//general nD
+    //general nD
 
-	if (nD!=3)
-	{
-	switch (CV_MAT_DEPTH(src->type))
-	{
-	case CV_8U:
-		for( y = 0; y < size.height; y++ )
-		{
-			uchar* sptr = src->data.ptr + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
-				//update GMM model
-				int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_16S:
-		for( y = 0; y < size.height; y++ )
-		{
-			short* sptr = src->data.s + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
-				//update GMM model
-				int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_16U:
-		for( y = 0; y < size.height; y++ )
-		{
-			unsigned short* sptr = (unsigned short*) (src->data.s + src->step*y);
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
-				//update GMM model
-				int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_32S:
-		for( y = 0; y < size.height; y++ )
-		{
-			int* sptr = src->data.i + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
-				//update GMM model
-				int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_32F:
-		for( y = 0; y < size.height; y++ )
-		{
-			float* sptr = src->data.fl + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//update GMM model
-				int result = _icvUpdateGMM(sptr,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_64F:
-		for( y = 0; y < size.height; y++ )
-		{
-			double* sptr = src->data.db + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
-				//update GMM model
-				int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	}
-	}else ///if (nD==3) - a bit faster
-	{
-	switch (CV_MAT_DEPTH(src->type))
-	{
-	case CV_8U:
-		for( y = 0; y < size.height; y++ )
-		{
-			uchar* sptr = src->data.ptr + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
-				//update GMM model
-				int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_16S:
-		for( y = 0; y < size.height; y++ )
-		{
-			short* sptr = src->data.s + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
-				//update GMM model
-				int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_16U:
-		for( y = 0; y < size.height; y++ )
-		{
-			unsigned short* sptr = (unsigned short*) src->data.s + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
-				//update GMM model
-				int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_32S:
-		for( y = 0; y < size.height; y++ )
-		{
-			int* sptr = src->data.i + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
-				//update GMM model
-				int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_32F:
-		for( y = 0; y < size.height; y++ )
-		{
-			float* sptr = src->data.fl + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//update GMM model
-				int result = _icvUpdateGMM_C3(sptr[0],sptr[1],sptr[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	case CV_64F:
-		for( y = 0; y < size.height; y++ )
-		{
-			double* sptr = src->data.db + src->step*y;
-			uchar* pDataOutput = dst->data.ptr + dst->step*y;
-			for( x = 0; x < size.width; x++,
-				pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
-			{
-				//convert data
-				data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
-				//update GMM model
-				int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
-				//detect shadows in the foreground
-				if (bShadowDetection)
-					if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
-				//generate output
-				(* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
-			}
-		}
-		break;
-	}
-	}//a bit faster for nD=3; 
+    if (nD!=3)
+    {
+    switch (CV_MAT_DEPTH(src->type))
+    {
+    case CV_8U:
+        for( y = 0; y < size.height; y++ )
+        {
+            uchar* sptr = src->data.ptr + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
+                //update GMM model
+                int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_16S:
+        for( y = 0; y < size.height; y++ )
+        {
+            short* sptr = src->data.s + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
+                //update GMM model
+                int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_16U:
+        for( y = 0; y < size.height; y++ )
+        {
+            unsigned short* sptr = (unsigned short*) (src->data.s + src->step*y);
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
+                //update GMM model
+                int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_32S:
+        for( y = 0; y < size.height; y++ )
+        {
+            int* sptr = src->data.i + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
+                //update GMM model
+                int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_32F:
+        for( y = 0; y < size.height; y++ )
+        {
+            float* sptr = src->data.fl + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //update GMM model
+                int result = _icvUpdateGMM(sptr,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_64F:
+        for( y = 0; y < size.height; y++ )
+        {
+            double* sptr = src->data.db + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                for (int iD=0;iD<nD;iD++) data[iD]=float(sptr[iD]);
+                //update GMM model
+                int result = _icvUpdateGMM(data,nD,pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    }
+    }else ///if (nD==3) - a bit faster
+    {
+    switch (CV_MAT_DEPTH(src->type))
+    {
+    case CV_8U:
+        for( y = 0; y < size.height; y++ )
+        {
+            uchar* sptr = src->data.ptr + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
+                //update GMM model
+                int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_16S:
+        for( y = 0; y < size.height; y++ )
+        {
+            short* sptr = src->data.s + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
+                //update GMM model
+                int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_16U:
+        for( y = 0; y < size.height; y++ )
+        {
+            unsigned short* sptr = (unsigned short*) src->data.s + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
+                //update GMM model
+                int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_32S:
+        for( y = 0; y < size.height; y++ )
+        {
+            int* sptr = src->data.i + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
+                //update GMM model
+                int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_32F:
+        for( y = 0; y < size.height; y++ )
+        {
+            float* sptr = src->data.fl + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //update GMM model
+                int result = _icvUpdateGMM_C3(sptr[0],sptr[1],sptr[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    case CV_64F:
+        for( y = 0; y < size.height; y++ )
+        {
+            double* sptr = src->data.db + src->step*y;
+            uchar* pDataOutput = dst->data.ptr + dst->step*y;
+            for( x = 0; x < size.width; x++,
+                pGMM+=nM,pUsedModes++,pDataOutput++,sptr+=nD)
+            {
+                //convert data
+                data[0]=float(sptr[0]),data[1]=float(sptr[1]),data[2]=float(sptr[2]);
+                //update GMM model
+                int result = _icvUpdateGMM_C3(data[0],data[1],data[2],pUsedModes,pGMM,nM,alpha, fTb, fTB, fTg, fVarInit, fVarMax, fVarMin,prune);
+                //detect shadows in the foreground
+                if (bShadowDetection)
+                    if (result==0) result= _icvRemoveShadowGMM(data,nD,(*pUsedModes),pGMM,fTb,fTB,fTau);
+                //generate output
+                (* pDataOutput)= (result==1) ? 0 : (result==2) ? (nShadowDetection) : 255; 
+            }
+        }
+        break;
+    }
+    }//a bit faster for nD=3; 
 }
 
 
@@ -953,93 +952,95 @@ CV_IMPL CvBGStatModel*
 cvCreateGaussianBGModel2( IplImage* first_frame, CvGaussBGStatModel2Params* parameters )
 {
     CvGaussBGModel2* bg_model = 0;
-	int w,h;
+    int w,h;
     
     CV_FUNCNAME( "cvCreateGaussianBGModel2" );
     
     __BEGIN__;
 
-	CvGaussBGStatModel2Params params;
+    CvGaussBGStatModel2Params params;
     
     if( !CV_IS_IMAGE(first_frame) )
         CV_ERROR( CV_StsBadArg, "Invalid or NULL first_frame parameter" );
 
-	if( first_frame->nChannels>CV_BGFG_MOG2_NDMAX )
+    if( first_frame->nChannels>CV_BGFG_MOG2_NDMAX )
         CV_ERROR( CV_StsBadArg, "Maxumum number of channels in the image is excedded (change CV_BGFG_MOG2_MAXBANDS constant)!" );
 
 
-	CV_CALL( bg_model = (CvGaussBGModel2*)cvAlloc( sizeof(*bg_model) ));
+    CV_CALL( bg_model = (CvGaussBGModel2*)cvAlloc( sizeof(*bg_model) ));
     memset( bg_model, 0, sizeof(*bg_model) );
     bg_model->type    = CV_BG_MODEL_MOG2;
     bg_model->release = (CvReleaseBGStatModel) icvReleaseGaussianBGModel2;
     bg_model->update  = (CvUpdateBGStatModel)  icvUpdateGaussianBGModel2;
 
-    //init parameters	
+    //init parameters   
     if( parameters == NULL )
-      {                        
-		/* These constants are defined in cvaux/include/cvaux.h: */
-		params.bShadowDetection = 1;
-		params.bPostFiltering=0;
-		params.minArea=CV_BGFG_MOG2_MINAREA;
+    {                        
+        memset(&params, 0, sizeof(params));
+        
+        /* These constants are defined in cvaux/include/cvaux.h: */
+        params.bShadowDetection = 1;
+        params.bPostFiltering=0;
+        params.minArea=CV_BGFG_MOG2_MINAREA;
 
-		//set parameters
-		// K - max number of Gaussians per pixel
-		params.nM = CV_BGFG_MOG2_NGAUSSIANS;//4;			
-		// Tb - the threshold - n var
-		//pGMM->fTb = 4*4;
-		params.fTb = CV_BGFG_MOG2_STD_THRESHOLD*CV_BGFG_MOG2_STD_THRESHOLD;
-		// Tbf - the threshold
-		//pGMM->fTB = 0.9f;//1-cf from the paper 
-		params.fTB = CV_BGFG_MOG2_BACKGROUND_THRESHOLD;
-		// Tgenerate - the threshold
-		params.fTg = CV_BGFG_MOG2_STD_THRESHOLD_GENERATE*CV_BGFG_MOG2_STD_THRESHOLD_GENERATE;//update the mode or generate new
-		//pGMM->fSigma= 11.0f;//sigma for the new mode
-		params.fVarInit = CV_BGFG_MOG2_VAR_INIT;
-		params.fVarMax = CV_BGFG_MOG2_VAR_MAX;
-		params.fVarMin = CV_BGFG_MOG2_VAR_MIN;
-		// alpha - the learning factor
-		params.fAlphaT = 1.0f/CV_BGFG_MOG2_WINDOW_SIZE;//0.003f;
-		// complexity reduction prior constant
-		params.fCT = CV_BGFG_MOG2_CT;//0.05f;
+        //set parameters
+        // K - max number of Gaussians per pixel
+        params.nM = CV_BGFG_MOG2_NGAUSSIANS;//4;            
+        // Tb - the threshold - n var
+        //pGMM->fTb = 4*4;
+        params.fTb = CV_BGFG_MOG2_STD_THRESHOLD*CV_BGFG_MOG2_STD_THRESHOLD;
+        // Tbf - the threshold
+        //pGMM->fTB = 0.9f;//1-cf from the paper 
+        params.fTB = CV_BGFG_MOG2_BACKGROUND_THRESHOLD;
+        // Tgenerate - the threshold
+        params.fTg = CV_BGFG_MOG2_STD_THRESHOLD_GENERATE*CV_BGFG_MOG2_STD_THRESHOLD_GENERATE;//update the mode or generate new
+        //pGMM->fSigma= 11.0f;//sigma for the new mode
+        params.fVarInit = CV_BGFG_MOG2_VAR_INIT;
+        params.fVarMax = CV_BGFG_MOG2_VAR_MAX;
+        params.fVarMin = CV_BGFG_MOG2_VAR_MIN;
+        // alpha - the learning factor
+        params.fAlphaT = 1.0f/CV_BGFG_MOG2_WINDOW_SIZE;//0.003f;
+        // complexity reduction prior constant
+        params.fCT = CV_BGFG_MOG2_CT;//0.05f;
 
-		//shadow
-		// Shadow detection
-		params.nShadowDetection = (unsigned char)CV_BGFG_MOG2_SHADOW_VALUE;//value 0 to turn off
-		params.fTau = CV_BGFG_MOG2_SHADOW_TAU;//0.5f;// Tau - shadow threshold
+        //shadow
+        // Shadow detection
+        params.nShadowDetection = (unsigned char)CV_BGFG_MOG2_SHADOW_VALUE;//value 0 to turn off
+        params.fTau = CV_BGFG_MOG2_SHADOW_TAU;//0.5f;// Tau - shadow threshold
     }
     else
     {
         params = *parameters;
     }
 
-	bg_model->params = params;
+    bg_model->params = params;
 
-	//image data 
-	w = first_frame->width;
-	h = first_frame->height;
+    //image data 
+    w = first_frame->width;
+    h = first_frame->height;
 
-	bg_model->params.nWidth = w;
-	bg_model->params.nHeight = h;
+    bg_model->params.nWidth = w;
+    bg_model->params.nHeight = h;
 
-	bg_model->params.nND = first_frame->nChannels;
+    bg_model->params.nND = first_frame->nChannels;
 
 
-	//allocate GMM data
+    //allocate GMM data
 
-	//GMM for each pixel
-	bg_model->data.rGMM = (CvPBGMMGaussian*) malloc(w*h * params.nM * sizeof(CvPBGMMGaussian));
-	//used modes per pixel
-	bg_model->data.rnUsedModes = (unsigned char* ) malloc(w*h);
-	memset(bg_model->data.rnUsedModes,0,w*h);//no modes used
+    //GMM for each pixel
+    bg_model->data.rGMM = (CvPBGMMGaussian*) malloc(w*h * params.nM * sizeof(CvPBGMMGaussian));
+    //used modes per pixel
+    bg_model->data.rnUsedModes = (unsigned char* ) malloc(w*h);
+    memset(bg_model->data.rnUsedModes,0,w*h);//no modes used
   
     //prepare storages    
     CV_CALL( bg_model->background = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, first_frame->nChannels));
     CV_CALL( bg_model->foreground = cvCreateImage(cvSize(w,h), IPL_DEPTH_8U, 1));
     
-	//for eventual filtering
+    //for eventual filtering
     CV_CALL( bg_model->storage = cvCreateMemStorage());
-	
-	bg_model->countFrames = 0;
+    
+    bg_model->countFrames = 0;
 
     __END__;
     
@@ -1072,8 +1073,8 @@ icvReleaseGaussianBGModel2( CvGaussBGModel2** _bg_model )
     {
         CvGaussBGModel2* bg_model = *_bg_model;
 
-		free (bg_model->data.rGMM);
-		free (bg_model->data.rnUsedModes);
+        free (bg_model->data.rGMM);
+        free (bg_model->data.rnUsedModes);
 
         cvReleaseImage( &bg_model->background );
         cvReleaseImage( &bg_model->foreground );
@@ -1089,87 +1090,87 @@ icvReleaseGaussianBGModel2( CvGaussBGModel2** _bg_model )
 static int CV_CDECL
 icvUpdateGaussianBGModel2( IplImage* curr_frame, CvGaussBGModel2*  bg_model )
 { 
-	//checks	
-	if ((curr_frame->height!=bg_model->params.nHeight)||(curr_frame->width!=bg_model->params.nWidth)||(curr_frame->nChannels!=bg_model->params.nND))
-		CV_Error( CV_StsBadSize, "the image not the same size as the reserved GMM background model");
+    //checks    
+    if ((curr_frame->height!=bg_model->params.nHeight)||(curr_frame->width!=bg_model->params.nWidth)||(curr_frame->nChannels!=bg_model->params.nND))
+        CV_Error( CV_StsBadSize, "the image not the same size as the reserved GMM background model");
 
-	float alpha=bg_model->params.fAlphaT;
-	bg_model->countFrames++;
-	
-	//faster initial updates - increase value of alpha
-	if (bg_model->params.bInit){
-		float alphaInit=(1.0f/(2*bg_model->countFrames+1));
-		if (alphaInit>alpha)
-		{
-			alpha = alphaInit;
-		}
-		else
-		{
-			bg_model->params.bInit = 0;
-		}
-	}
+    float alpha=bg_model->params.fAlphaT;
+    bg_model->countFrames++;
+    
+    //faster initial updates - increase value of alpha
+    if (bg_model->params.bInit){
+        float alphaInit=(1.0f/(2*bg_model->countFrames+1));
+        if (alphaInit>alpha)
+        {
+            alpha = alphaInit;
+        }
+        else
+        {
+            bg_model->params.bInit = 0;
+        }
+    }
 
-	//update background
-	//icvUpdatePixelBackgroundGMM2( curr_frame, bg_model->foreground, bg_model->data.rGMM,bg_model->data.rnUsedModes,&(bg_model->params),alpha);
-	icvUpdatePixelBackgroundGMM2( curr_frame, bg_model->foreground, bg_model->data.rGMM,bg_model->data.rnUsedModes,
-		bg_model->params.nM,
-		bg_model->params.fTb,
-		bg_model->params.fTB,
-		bg_model->params.fTg,
-		bg_model->params.fVarInit,
-		bg_model->params.fVarMax,
-		bg_model->params.fVarMin,
-		bg_model->params.fCT,
-		bg_model->params.fTau,
-		bg_model->params.bShadowDetection,
-		bg_model->params.nShadowDetection,
-		alpha);
+    //update background
+    //icvUpdatePixelBackgroundGMM2( curr_frame, bg_model->foreground, bg_model->data.rGMM,bg_model->data.rnUsedModes,&(bg_model->params),alpha);
+    icvUpdatePixelBackgroundGMM2( curr_frame, bg_model->foreground, bg_model->data.rGMM,bg_model->data.rnUsedModes,
+        bg_model->params.nM,
+        bg_model->params.fTb,
+        bg_model->params.fTB,
+        bg_model->params.fTg,
+        bg_model->params.fVarInit,
+        bg_model->params.fVarMax,
+        bg_model->params.fVarMin,
+        bg_model->params.fCT,
+        bg_model->params.fTau,
+        bg_model->params.bShadowDetection,
+        bg_model->params.nShadowDetection,
+        alpha);
 
-	//foreground filtering
-	if (bg_model->params.bPostFiltering==1)
-	{
-		int region_count = 0;
-		CvSeq *first_seq = NULL, *prev_seq = NULL, *seq = NULL;
+    //foreground filtering
+    if (bg_model->params.bPostFiltering==1)
+    {
+        int region_count = 0;
+        CvSeq *first_seq = NULL, *prev_seq = NULL, *seq = NULL;
 
 
-		//filter small regions
-		cvClearMemStorage(bg_model->storage);
+        //filter small regions
+        cvClearMemStorage(bg_model->storage);
 
-		cvMorphologyEx( bg_model->foreground, bg_model->foreground, 0, 0, CV_MOP_OPEN, 1 );
-		cvMorphologyEx( bg_model->foreground, bg_model->foreground, 0, 0, CV_MOP_CLOSE, 1 );
+        cvMorphologyEx( bg_model->foreground, bg_model->foreground, 0, 0, CV_MOP_OPEN, 1 );
+        cvMorphologyEx( bg_model->foreground, bg_model->foreground, 0, 0, CV_MOP_CLOSE, 1 );
 
-		cvFindContours( bg_model->foreground, bg_model->storage, &first_seq, sizeof(CvContour), CV_RETR_LIST );
-		for( seq = first_seq; seq; seq = seq->h_next )
-		{
-			CvContour* cnt = (CvContour*)seq;
-			if( cnt->rect.width * cnt->rect.height < bg_model->params.minArea )
-			{
-				//delete small contour
-				prev_seq = seq->h_prev;
-				if( prev_seq )
-				{
-					prev_seq->h_next = seq->h_next;
-					if( seq->h_next ) seq->h_next->h_prev = prev_seq;
-				}
-				else
-				{
-					first_seq = seq->h_next;
-					if( seq->h_next ) seq->h_next->h_prev = NULL;
-				}
-			}
-			else
-			{
-				region_count++;
-			}
-		}
-		bg_model->foreground_regions = first_seq;
-		cvZero(bg_model->foreground);
-		cvDrawContours(bg_model->foreground, first_seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
+        cvFindContours( bg_model->foreground, bg_model->storage, &first_seq, sizeof(CvContour), CV_RETR_LIST );
+        for( seq = first_seq; seq; seq = seq->h_next )
+        {
+            CvContour* cnt = (CvContour*)seq;
+            if( cnt->rect.width * cnt->rect.height < bg_model->params.minArea )
+            {
+                //delete small contour
+                prev_seq = seq->h_prev;
+                if( prev_seq )
+                {
+                    prev_seq->h_next = seq->h_next;
+                    if( seq->h_next ) seq->h_next->h_prev = prev_seq;
+                }
+                else
+                {
+                    first_seq = seq->h_next;
+                    if( seq->h_next ) seq->h_next->h_prev = NULL;
+                }
+            }
+            else
+            {
+                region_count++;
+            }
+        }
+        bg_model->foreground_regions = first_seq;
+        cvZero(bg_model->foreground);
+        cvDrawContours(bg_model->foreground, first_seq, CV_RGB(0, 0, 255), CV_RGB(0, 0, 255), 10, -1);
 
-		return region_count; 
-	}
+        return region_count; 
+    }
 
-	return 1;
+    return 1;
 }
 
 
@@ -1196,19 +1197,19 @@ BackgroundSubtractorMOG2::BackgroundSubtractorMOG2()
     
     nframes = 0;
     history = defaultHistory2;
-	varThreshold = defaultVarThreshold2;
-	bShadowDetection = 1;
+    varThreshold = defaultVarThreshold2;
+    bShadowDetection = 1;
 
-	nmixtures = defaultNMixtures2;   
-	backgroundRatio = defaultBackgroundRatio2;
-	fVarInit = defaultVarInit2;
-	fVarMax  = defaultVarMax2;
-	fVarMin = defaultVarMin2;
+    nmixtures = defaultNMixtures2;   
+    backgroundRatio = defaultBackgroundRatio2;
+    fVarInit = defaultVarInit2;
+    fVarMax  = defaultVarMax2;
+    fVarMin = defaultVarMin2;
 
-	varThresholdGen = defaultVarThresholdGen2;
-	fCT = defaultfCT2;
-	nShadowDetection =  defaultnShadowDetection2;
-	fTau = defaultfTau;
+    varThresholdGen = defaultVarThresholdGen2;
+    fCT = defaultfCT2;
+    nShadowDetection =  defaultnShadowDetection2;
+    fTau = defaultfTau;
 }
     
 BackgroundSubtractorMOG2::BackgroundSubtractorMOG2(int _history,  float _varThreshold, bool _bShadowDetection)
@@ -1218,19 +1219,19 @@ BackgroundSubtractorMOG2::BackgroundSubtractorMOG2(int _history,  float _varThre
     
     nframes = 0;
     history = _history > 0 ? _history : defaultHistory2;
-	varThreshold = (_varThreshold>0)? _varThreshold : defaultVarThreshold2;
-	bShadowDetection = _bShadowDetection;
+    varThreshold = (_varThreshold>0)? _varThreshold : defaultVarThreshold2;
+    bShadowDetection = _bShadowDetection;
 
-	nmixtures = defaultNMixtures2;   
-	backgroundRatio = defaultBackgroundRatio2;
-	fVarInit = defaultVarInit2;
-	fVarMax  = defaultVarMax2;
-	fVarMin = defaultVarMin2;
+    nmixtures = defaultNMixtures2;   
+    backgroundRatio = defaultBackgroundRatio2;
+    fVarInit = defaultVarInit2;
+    fVarMax  = defaultVarMax2;
+    fVarMin = defaultVarMin2;
 
-	varThresholdGen = defaultVarThresholdGen2;
-	fCT = defaultfCT2;
-	nShadowDetection =  defaultnShadowDetection2;
-	fTau = defaultfTau;
+    varThresholdGen = defaultVarThresholdGen2;
+    fCT = defaultfCT2;
+    nShadowDetection =  defaultnShadowDetection2;
+    fTau = defaultfTau;
 }
     
 BackgroundSubtractorMOG2::~BackgroundSubtractorMOG2()
@@ -1245,15 +1246,15 @@ void BackgroundSubtractorMOG2::initialize(Size _frameSize, int _frameType)
     nframes = 0;
     
     int nchannels = CV_MAT_CN(frameType);
-	CV_Assert( nchannels <= CV_BGFG_MOG2_NDMAX );
+    CV_Assert( nchannels <= CV_BGFG_MOG2_NDMAX );
     
     // for each gaussian mixture of each pixel bg model we store ...
     // the mixture weight (w),
     // the mean (nchannels values) and
     // the covariance
     bgmodel.create( 1, frameSize.height*frameSize.width*nmixtures*(2 + CV_BGFG_MOG2_NDMAX), CV_32F );
-	//make the array for keeping track of the used modes per pixel - all zeros at start
-	bgmodelUsedModes.create(frameSize,CV_8U);
+    //make the array for keeping track of the used modes per pixel - all zeros at start
+    bgmodelUsedModes.create(frameSize,CV_8U);
     bgmodelUsedModes = Scalar::all(0);
 }
 
@@ -1273,22 +1274,22 @@ void BackgroundSubtractorMOG2::operator()(InputArray _image, OutputArray _fgmask
     CV_Assert(learningRate >= 0);
     CvMat _cimage = image, _cfgmask = fgmask;
     
-	if (learningRate > 0) 
-		icvUpdatePixelBackgroundGMM2( &_cimage, &_cfgmask, 
-		(CvPBGMMGaussian*) bgmodel.data,
-		bgmodelUsedModes.data,
-		nmixtures,//nM
-		varThreshold,//fTb
-		backgroundRatio,//fTB
-		varThresholdGen,//fTg,
-		fVarInit,
-		fVarMax,
-		fVarMin,
-		fCT,
-		fTau,
-		bShadowDetection,
-		nShadowDetection,
-		float(learningRate));
+    if (learningRate > 0) 
+        icvUpdatePixelBackgroundGMM2( &_cimage, &_cfgmask, 
+        (CvPBGMMGaussian*) bgmodel.data,
+        bgmodelUsedModes.data,
+        nmixtures,//nM
+        varThreshold,//fTb
+        backgroundRatio,//fTB
+        varThresholdGen,//fTg,
+        fVarInit,
+        fVarMax,
+        fVarMin,
+        fCT,
+        fTau,
+        bShadowDetection,
+        nShadowDetection,
+        float(learningRate));
 }
 
 void BackgroundSubtractorMOG2::getBackgroundImage(OutputArray backgroundImage) const
diff --git a/modules/video/src/lkpyramid.cpp b/modules/video/src/lkpyramid.cpp
index b1a5101c4c..397eda5ffd 100644
--- a/modules/video/src/lkpyramid.cpp
+++ b/modules/video/src/lkpyramid.cpp
@@ -42,13 +42,464 @@
 #include <float.h>
 #include <stdio.h>
 
+namespace cv
+{
+
+typedef short deriv_type;
+    
+static void calcSharrDeriv(const Mat& src, Mat& dst)
+{
+    int rows = src.rows, cols = src.cols, cn = src.channels(), colsn = cols*cn, depth = src.depth();
+    CV_Assert(depth == CV_8U);
+    dst.create(rows, cols, CV_MAKETYPE(DataType<deriv_type>::depth, cn*2));
+    
+    int x, y, delta = (int)alignSize((cols + 2)*cn, 16);
+    AutoBuffer<deriv_type> _tempBuf(delta*2 + 64);
+    deriv_type *trow0 = alignPtr(_tempBuf + cn, 16), *trow1 = alignPtr(trow0 + delta, 16);
+    
+#if CV_SSE2
+    __m128i z = _mm_setzero_si128(), c3 = _mm_set1_epi16(3), c10 = _mm_set1_epi16(10);
+#endif
+    
+    for( y = 0; y < rows; y++ )
+    {
+        const uchar* srow0 = src.ptr<uchar>(y > 0 ? y-1 : rows > 1 ? 1 : 0);
+        const uchar* srow1 = src.ptr<uchar>(y);
+        const uchar* srow2 = src.ptr<uchar>(y < rows-1 ? y+1 : rows > 1 ? rows-2 : 0);
+        deriv_type* drow = dst.ptr<deriv_type>(y);
+        
+        // do vertical convolution
+        x = 0;
+#if CV_SSE2
+        for( ; x <= colsn - 8; x += 8 )
+        {
+            __m128i s0 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(srow0 + x)), z);
+            __m128i s1 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(srow1 + x)), z);
+            __m128i s2 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(srow2 + x)), z);
+            __m128i t0 = _mm_add_epi16(_mm_mullo_epi16(_mm_add_epi16(s0, s2), c3), _mm_mullo_epi16(s1, c10));
+            __m128i t1 = _mm_sub_epi16(s2, s0);
+            _mm_store_si128((__m128i*)(trow0 + x), t0);
+            _mm_store_si128((__m128i*)(trow1 + x), t1);
+        }
+#endif
+        for( ; x < colsn; x++ )
+        {
+            int t0 = (srow0[x] + srow2[x])*3 + srow1[x]*10;
+            int t1 = srow2[x] - srow0[x];
+            trow0[x] = (deriv_type)t0;
+            trow1[x] = (deriv_type)t1;
+        }
+        
+        // make border
+        int x0 = (cols > 1 ? 1 : 0)*cn, x1 = (cols > 1 ? cols-2 : 0)*cn;
+        for( int k = 0; k < cn; k++ )
+        {
+            trow0[-cn + k] = trow0[x0 + k]; trow0[colsn + k] = trow0[x1 + k];
+            trow1[-cn + k] = trow1[x0 + k]; trow1[colsn + k] = trow1[x1 + k];
+        }
+            
+        // do horizontal convolution, interleave the results and store them to dst
+        x = 0;
+#if CV_SSE2
+        for( ; x <= colsn - 8; x += 8 )
+        {
+            __m128i s0 = _mm_loadu_si128((const __m128i*)(trow0 + x - cn));
+            __m128i s1 = _mm_loadu_si128((const __m128i*)(trow0 + x + cn));
+            __m128i s2 = _mm_loadu_si128((const __m128i*)(trow1 + x - cn));
+            __m128i s3 = _mm_load_si128((const __m128i*)(trow1 + x));
+            __m128i s4 = _mm_loadu_si128((const __m128i*)(trow1 + x + cn));
+            
+            __m128i t0 = _mm_sub_epi16(s1, s0);
+            __m128i t1 = _mm_add_epi16(_mm_mullo_epi16(_mm_add_epi16(s2, s4), c3), _mm_mullo_epi16(s3, c10));
+            __m128i t2 = _mm_unpacklo_epi16(t0, t1);
+            t0 = _mm_unpackhi_epi16(t0, t1);
+            // this can probably be replaced with aligned stores if we aligned dst properly.
+            _mm_storeu_si128((__m128i*)(drow + x*2), t2);
+            _mm_storeu_si128((__m128i*)(drow + x*2 + 8), t0);
+        }
+#endif        
+        for( ; x < colsn; x++ )
+        {
+            deriv_type t0 = (deriv_type)(trow0[x+cn] - trow0[x-cn]);
+            deriv_type t1 = (deriv_type)((trow1[x+cn] + trow1[x-cn])*3 + trow1[x]*10);
+            drow[x*2] = t0; drow[x*2+1] = t1;
+        }
+    }
+}
+
+    
+struct LKTrackerInvoker
+{
+    LKTrackerInvoker( const Mat& _prevImg, const Mat& _prevDeriv, const Mat& _nextImg,
+                      const Point2f* _prevPts, Point2f* _nextPts,
+                      uchar* _status, float* _err,
+                      Size _winSize, TermCriteria _criteria,
+                      int _level, int _maxLevel, int _flags, float _minEigThreshold )
+    {
+        prevImg = &_prevImg;
+        prevDeriv = &_prevDeriv;
+        nextImg = &_nextImg;
+        prevPts = _prevPts;
+        nextPts = _nextPts;
+        status = _status;
+        err = _err;
+        winSize = _winSize;
+        criteria = _criteria;
+        level = _level;
+        maxLevel = _maxLevel;
+        flags = _flags;
+        minEigThreshold = _minEigThreshold;
+    }
+    
+    void operator()(const BlockedRange& range) const
+    {
+        Point2f halfWin((winSize.width-1)*0.5f, (winSize.height-1)*0.5f);
+        const Mat& I = *prevImg;
+        const Mat& J = *nextImg;
+        const Mat& derivI = *prevDeriv;
+        
+        int j, cn = I.channels(), cn2 = cn*2;
+        cv::AutoBuffer<deriv_type> _buf(winSize.area()*(cn + cn2));
+        int derivDepth = DataType<deriv_type>::depth;
+        
+        Mat IWinBuf(winSize, CV_MAKETYPE(derivDepth, cn), (deriv_type*)_buf);
+        Mat derivIWinBuf(winSize, CV_MAKETYPE(derivDepth, cn2), (deriv_type*)_buf + winSize.area()*cn);
+        
+        for( int ptidx = range.begin(); ptidx < range.end(); ptidx++ )
+        {
+            Point2f prevPt = prevPts[ptidx]*(float)(1./(1 << level));
+            Point2f nextPt;
+            if( level == maxLevel )
+            {
+                if( flags & OPTFLOW_USE_INITIAL_FLOW )
+                    nextPt = nextPts[ptidx]*(float)(1./(1 << level));
+                else
+                    nextPt = prevPt;
+            }
+            else
+                nextPt = nextPts[ptidx]*2.f;
+            nextPts[ptidx] = nextPt;
+            
+            Point2i iprevPt, inextPt;
+            prevPt -= halfWin;
+            iprevPt.x = cvFloor(prevPt.x);
+            iprevPt.y = cvFloor(prevPt.y);
+            
+            if( iprevPt.x < -winSize.width || iprevPt.x >= derivI.cols ||
+                iprevPt.y < -winSize.height || iprevPt.y >= derivI.rows )
+            {
+                if( level == 0 )
+                {
+                    if( status )
+                        status[ptidx] = false;
+                    if( err )
+                        err[ptidx] = 0;
+                }
+                continue;
+            }
+            
+            float a = prevPt.x - iprevPt.x;
+            float b = prevPt.y - iprevPt.y;
+            const int W_BITS = 14, W_BITS1 = 14;
+            const float FLT_SCALE = 1.f/(1 << 20);
+            int iw00 = cvRound((1.f - a)*(1.f - b)*(1 << W_BITS));
+            int iw01 = cvRound(a*(1.f - b)*(1 << W_BITS));
+            int iw10 = cvRound((1.f - a)*b*(1 << W_BITS));
+            int iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+            
+            int dstep = (int)(derivI.step/derivI.elemSize1());
+            int step = (int)(I.step/I.elemSize1());
+            CV_Assert( step == (int)(J.step/J.elemSize1()) );
+            float A11 = 0, A12 = 0, A22 = 0;
+            
+#if CV_SSE2
+            __m128i qw0 = _mm_set1_epi32(iw00 + (iw01 << 16));
+            __m128i qw1 = _mm_set1_epi32(iw10 + (iw11 << 16));
+            __m128i z = _mm_setzero_si128();
+            __m128i qdelta_d = _mm_set1_epi32(1 << (W_BITS1-1));
+            __m128i qdelta = _mm_set1_epi32(1 << (W_BITS1-5-1));
+            __m128 qA11 = _mm_setzero_ps(), qA12 = _mm_setzero_ps(), qA22 = _mm_setzero_ps();
+#endif
+            
+            // extract the patch from the first image, compute covariation matrix of derivatives
+            int x, y;
+            for( y = 0; y < winSize.height; y++ )
+            {
+                const uchar* src = (const uchar*)I.data + (y + iprevPt.y)*step + iprevPt.x*cn;
+                const deriv_type* dsrc = (const deriv_type*)derivI.data + (y + iprevPt.y)*dstep + iprevPt.x*cn2;
+                
+                deriv_type* Iptr = (deriv_type*)(IWinBuf.data + y*IWinBuf.step);
+                deriv_type* dIptr = (deriv_type*)(derivIWinBuf.data + y*derivIWinBuf.step);
+                
+                x = 0;
+                
+#if CV_SSE2
+                for( ; x <= winSize.width*cn - 4; x += 4, dsrc += 4*2, dIptr += 4*2 )
+                {
+                    __m128i v00, v01, v10, v11, t0, t1;
+                    
+                    v00 = _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(const int*)(src + x)), z);
+                    v01 = _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(const int*)(src + x + cn)), z);
+                    v10 = _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(const int*)(src + x + step)), z);
+                    v11 = _mm_unpacklo_epi8(_mm_cvtsi32_si128(*(const int*)(src + x + step + cn)), z);
+                    
+                    t0 = _mm_add_epi32(_mm_madd_epi16(_mm_unpacklo_epi16(v00, v01), qw0),
+                                       _mm_madd_epi16(_mm_unpacklo_epi16(v10, v11), qw1));
+                    t0 = _mm_srai_epi32(_mm_add_epi32(t0, qdelta), W_BITS1-5);
+                    _mm_storel_epi64((__m128i*)(Iptr + x), _mm_packs_epi32(t0,t0));
+                    
+                    v00 = _mm_loadu_si128((const __m128i*)(dsrc));
+                    v01 = _mm_loadu_si128((const __m128i*)(dsrc + cn2));
+                    v10 = _mm_loadu_si128((const __m128i*)(dsrc + dstep));
+                    v11 = _mm_loadu_si128((const __m128i*)(dsrc + dstep + cn2));
+                    
+                    t0 = _mm_add_epi32(_mm_madd_epi16(_mm_unpacklo_epi16(v00, v01), qw0),
+                                       _mm_madd_epi16(_mm_unpacklo_epi16(v10, v11), qw1));
+                    t1 = _mm_add_epi32(_mm_madd_epi16(_mm_unpackhi_epi16(v00, v01), qw0),
+                                       _mm_madd_epi16(_mm_unpackhi_epi16(v10, v11), qw1));
+                    t0 = _mm_srai_epi32(_mm_add_epi32(t0, qdelta_d), W_BITS1);
+                    t1 = _mm_srai_epi32(_mm_add_epi32(t1, qdelta_d), W_BITS1);
+                    v00 = _mm_packs_epi32(t0, t1); // Ix0 Iy0 Ix1 Iy1 ...
+                    
+                    _mm_storeu_si128((__m128i*)dIptr, v00);
+                    t0 = _mm_srai_epi32(v00, 16); // Iy0 Iy1 Iy2 Iy3
+                    t1 = _mm_srai_epi32(_mm_slli_epi32(v00, 16), 16); // Ix0 Ix1 Ix2 Ix3
+                    
+                    __m128 fy = _mm_cvtepi32_ps(t0);
+                    __m128 fx = _mm_cvtepi32_ps(t1);
+                    
+                    qA22 = _mm_add_ps(qA22, _mm_mul_ps(fy, fy));
+                    qA12 = _mm_add_ps(qA12, _mm_mul_ps(fx, fy));
+                    qA11 = _mm_add_ps(qA11, _mm_mul_ps(fx, fx));
+                }
+#endif
+                
+                for( ; x < winSize.width*cn; x++, dsrc += 2, dIptr += 2 )
+                {
+                    int ival = CV_DESCALE(src[x]*iw00 + src[x+cn]*iw01 +
+                                          src[x+step]*iw10 + src[x+step+cn]*iw11, W_BITS1-5);
+                    int ixval = CV_DESCALE(dsrc[0]*iw00 + dsrc[cn2]*iw01 +
+                                           dsrc[dstep]*iw10 + dsrc[dstep+cn2]*iw11, W_BITS1);
+                    int iyval = CV_DESCALE(dsrc[1]*iw00 + dsrc[cn2+1]*iw01 + dsrc[dstep+1]*iw10 +
+                                           dsrc[dstep+cn2+1]*iw11, W_BITS1);
+                    
+                    Iptr[x] = (short)ival;
+                    dIptr[0] = (short)ixval;
+                    dIptr[1] = (short)iyval;
+                    
+                    A11 += (float)(ixval*ixval);
+                    A12 += (float)(ixval*iyval);
+                    A22 += (float)(iyval*iyval);
+                }
+            }
+            
+#if CV_SSE2
+            float CV_DECL_ALIGNED(16) A11buf[4], A12buf[4], A22buf[4];
+            _mm_store_ps(A11buf, qA11);
+            _mm_store_ps(A12buf, qA12);
+            _mm_store_ps(A22buf, qA22);
+            A11 += A11buf[0] + A11buf[1] + A11buf[2] + A11buf[3];
+            A12 += A12buf[0] + A12buf[1] + A12buf[2] + A12buf[3];
+            A22 += A22buf[0] + A22buf[1] + A22buf[2] + A22buf[3];
+#endif
+            
+            A11 *= FLT_SCALE;
+            A12 *= FLT_SCALE;
+            A22 *= FLT_SCALE;
+            
+            float D = A11*A22 - A12*A12;
+            float minEig = (A22 + A11 - std::sqrt((A11-A22)*(A11-A22) +
+                            4.f*A12*A12))/(2*winSize.width*winSize.height);
+            
+            if( err && (flags & CV_LKFLOW_GET_MIN_EIGENVALS) != 0 )
+                err[ptidx] = (float)minEig;
+            
+            if( minEig < minEigThreshold || D < FLT_EPSILON )
+            {
+                if( level == 0 && status )
+                    status[ptidx] = false;
+                continue;
+            }
+            
+            D = 1.f/D;
+            
+            nextPt -= halfWin;
+            Point2f prevDelta;
+            
+            for( j = 0; j < criteria.maxCount; j++ )
+            {
+                inextPt.x = cvFloor(nextPt.x);
+                inextPt.y = cvFloor(nextPt.y);
+                
+                if( inextPt.x < -winSize.width || inextPt.x >= J.cols ||
+                   inextPt.y < -winSize.height || inextPt.y >= J.rows )
+                {
+                    if( level == 0 && status )
+                        status[ptidx] = false;
+                    break;
+                }
+                
+                a = nextPt.x - inextPt.x;
+                b = nextPt.y - inextPt.y;
+                iw00 = cvRound((1.f - a)*(1.f - b)*(1 << W_BITS));
+                iw01 = cvRound(a*(1.f - b)*(1 << W_BITS));
+                iw10 = cvRound((1.f - a)*b*(1 << W_BITS));
+                iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+                float b1 = 0, b2 = 0;
+#if CV_SSE2
+                qw0 = _mm_set1_epi32(iw00 + (iw01 << 16));
+                qw1 = _mm_set1_epi32(iw10 + (iw11 << 16));
+                __m128 qb0 = _mm_setzero_ps(), qb1 = _mm_setzero_ps();
+#endif
+                
+                for( y = 0; y < winSize.height; y++ )
+                {
+                    const uchar* Jptr = (const uchar*)J.data + (y + inextPt.y)*step + inextPt.x*cn;
+                    const deriv_type* Iptr = (const deriv_type*)(IWinBuf.data + y*IWinBuf.step);
+                    const deriv_type* dIptr = (const deriv_type*)(derivIWinBuf.data + y*derivIWinBuf.step);
+                    
+                    x = 0;
+                    
+#if CV_SSE2
+                    for( ; x <= winSize.width*cn - 8; x += 8, dIptr += 8*2 )
+                    {
+                        __m128i diff0 = _mm_loadu_si128((const __m128i*)(Iptr + x)), diff1;
+                        __m128i v00 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(Jptr + x)), z);
+                        __m128i v01 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(Jptr + x + cn)), z);
+                        __m128i v10 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(Jptr + x + step)), z);
+                        __m128i v11 = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(Jptr + x + step + cn)), z);
+                        
+                        __m128i t0 = _mm_add_epi32(_mm_madd_epi16(_mm_unpacklo_epi16(v00, v01), qw0),
+                                                   _mm_madd_epi16(_mm_unpacklo_epi16(v10, v11), qw1));
+                        __m128i t1 = _mm_add_epi32(_mm_madd_epi16(_mm_unpackhi_epi16(v00, v01), qw0),
+                                                   _mm_madd_epi16(_mm_unpackhi_epi16(v10, v11), qw1));
+                        t0 = _mm_srai_epi32(_mm_add_epi32(t0, qdelta), W_BITS1-5);
+                        t1 = _mm_srai_epi32(_mm_add_epi32(t1, qdelta), W_BITS1-5);
+                        diff0 = _mm_subs_epi16(_mm_packs_epi32(t0, t1), diff0);
+                        diff1 = _mm_unpackhi_epi16(diff0, diff0);
+                        diff0 = _mm_unpacklo_epi16(diff0, diff0); // It0 It0 It1 It1 ...
+                        v00 = _mm_loadu_si128((const __m128i*)(dIptr)); // Ix0 Iy0 Ix1 Iy1 ... 
+                        v01 = _mm_loadu_si128((const __m128i*)(dIptr + 8));
+                        v10 = _mm_mullo_epi16(v00, diff0);
+                        v11 = _mm_mulhi_epi16(v00, diff0);
+                        v00 = _mm_unpacklo_epi16(v10, v11);
+                        v10 = _mm_unpackhi_epi16(v10, v11);
+                        qb0 = _mm_add_ps(qb0, _mm_cvtepi32_ps(v00));
+                        qb1 = _mm_add_ps(qb1, _mm_cvtepi32_ps(v10));
+                        v10 = _mm_mullo_epi16(v01, diff1);
+                        v11 = _mm_mulhi_epi16(v01, diff1);
+                        v00 = _mm_unpacklo_epi16(v10, v11);
+                        v10 = _mm_unpackhi_epi16(v10, v11);
+                        qb0 = _mm_add_ps(qb0, _mm_cvtepi32_ps(v00));
+                        qb1 = _mm_add_ps(qb1, _mm_cvtepi32_ps(v10));
+                    }
+#endif
+                    
+                    for( ; x < winSize.width*cn; x++, dIptr += 2 )
+                    {
+                        int diff = CV_DESCALE(Jptr[x]*iw00 + Jptr[x+cn]*iw01 +
+                                              Jptr[x+step]*iw10 + Jptr[x+step+cn]*iw11,
+                                              W_BITS1-5) - Iptr[x];
+                        b1 += (float)(diff*dIptr[0]);
+                        b2 += (float)(diff*dIptr[1]);
+                    }
+                }
+                
+#if CV_SSE2
+                float CV_DECL_ALIGNED(16) bbuf[4];
+                _mm_store_ps(bbuf, _mm_add_ps(qb0, qb1));
+                b1 += bbuf[0] + bbuf[2];
+                b2 += bbuf[1] + bbuf[3];
+#endif
+                
+                b1 *= FLT_SCALE;
+                b2 *= FLT_SCALE;
+                
+                Point2f delta( (float)((A12*b2 - A22*b1) * D),
+                              (float)((A12*b1 - A11*b2) * D));
+                //delta = -delta;
+                
+                nextPt += delta;
+                nextPts[ptidx] = nextPt + halfWin;
+                
+                if( delta.ddot(delta) <= criteria.epsilon )
+                    break;
+                
+                if( j > 0 && std::abs(delta.x + prevDelta.x) < 0.01 &&
+                   std::abs(delta.y + prevDelta.y) < 0.01 )
+                {
+                    nextPts[ptidx] -= delta*0.5f;
+                    break;
+                }
+                prevDelta = delta;
+            }
+            
+            if( status[ptidx] && err && level == 0 && (flags & CV_LKFLOW_GET_MIN_EIGENVALS) == 0 )
+            {
+                Point2f nextPt = nextPts[ptidx];
+                Point inextPt;
+                
+                inextPt.x = cvFloor(nextPt.x);
+                inextPt.y = cvFloor(nextPt.y);
+                
+                if( inextPt.x < -winSize.width || inextPt.x >= J.cols ||
+                    inextPt.y < -winSize.height || inextPt.y >= J.rows )
+                {
+                    if( status )
+                        status[ptidx] = false;
+                    continue;
+                }
+                
+                float a = nextPt.x - inextPt.x;
+                float b = nextPt.y - inextPt.y;
+                iw00 = cvRound((1.f - a)*(1.f - b)*(1 << W_BITS));
+                iw01 = cvRound(a*(1.f - b)*(1 << W_BITS));
+                iw10 = cvRound((1.f - a)*b*(1 << W_BITS));
+                iw11 = (1 << W_BITS) - iw00 - iw01 - iw10;
+                float errval = 0.f;
+                
+                for( y = 0; y < winSize.height; y++ )
+                {
+                    const uchar* Jptr = (const uchar*)J.data + (y + inextPt.y)*step + inextPt.x*cn;
+                    const deriv_type* Iptr = (const deriv_type*)(IWinBuf.data + y*IWinBuf.step);
+                    
+                    for( x = 0; x < winSize.width*cn; x++ )
+                    {
+                        int diff = CV_DESCALE(Jptr[x]*iw00 + Jptr[x+cn]*iw01 +
+                                              Jptr[x+step]*iw10 + Jptr[x+step+cn]*iw11,
+                                              W_BITS1-5) - Iptr[x];
+                        errval += std::abs((float)diff);
+                    }
+                }
+                err[ptidx] = errval * 1.f/(32*winSize.width*cn*winSize.height);
+            }
+        }
+    }
+    
+    const Mat* prevImg;
+    const Mat* nextImg;
+    const Mat* prevDeriv;
+    const Point2f* prevPts;
+    Point2f* nextPts;
+    uchar* status;
+    float* err;
+    Size winSize;
+    TermCriteria criteria;
+    int level;
+    int maxLevel;
+    int flags;
+    float minEigThreshold;
+};
+    
+}
+
 void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
                            InputArray _prevPts, InputOutputArray _nextPts,
                            OutputArray _status, OutputArray _err,
                            Size winSize, int maxLevel,
                            TermCriteria criteria,
                            double derivLambda,
-                           int flags )
+                           int flags, double minEigThreshold )
 {
 #ifdef HAVE_TEGRA_OPTIMIZATION
     if (tegra::calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err, winSize, maxLevel, criteria, derivLambda, flags))
@@ -56,18 +507,14 @@ void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
 #endif
     Mat prevImg = _prevImg.getMat(), nextImg = _nextImg.getMat(), prevPtsMat = _prevPts.getMat();
     derivLambda = std::min(std::max(derivLambda, 0.), 1.);
-    double lambda1 = 1. - derivLambda, lambda2 = derivLambda;
-    const int derivKernelSize = 3;
-    const float deriv1Scale = 0.5f/4.f;
-    const float deriv2Scale = 0.25f/4.f;
-    const int derivDepth = CV_32F;
-    Point2f halfWin((winSize.width-1)*0.5f, (winSize.height-1)*0.5f);
+    const int derivDepth = DataType<deriv_type>::depth;
 
+    CV_Assert( derivLambda >= 0 );
     CV_Assert( maxLevel >= 0 && winSize.width > 2 && winSize.height > 2 );
     CV_Assert( prevImg.size() == nextImg.size() &&
         prevImg.type() == nextImg.type() );
 
-    int npoints;
+    int level=0, i, k, npoints, cn = prevImg.channels(), cn2 = cn*2;
     CV_Assert( (npoints = prevPtsMat.checkVector(2, CV_32F, true)) >= 0 );
     
     if( npoints == 0 )
@@ -93,7 +540,7 @@ void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
     uchar* status = statusMat.data;
     float* err = 0;
     
-    for( int i = 0; i < npoints; i++ )
+    for( i = 0; i < npoints; i++ )
         status[i] = true;
     
     if( _err.needed() )
@@ -104,21 +551,43 @@ void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
         err = (float*)errMat.data;
     }
 
-    vector<Mat> prevPyr, nextPyr;
-
-    int cn = prevImg.channels();
-    buildPyramid( prevImg, prevPyr, maxLevel );
-    buildPyramid( nextImg, nextPyr, maxLevel );
-    // I, dI/dx ~ Ix, dI/dy ~ Iy, d2I/dx2 ~ Ixx, d2I/dxdy ~ Ixy, d2I/dy2 ~ Iyy
+    vector<Mat> prevPyr(maxLevel+1), nextPyr(maxLevel+1);
+    
+    // build the image pyramids.
+    // we pad each level with +/-winSize.{width|height}
+    // pixels to simplify the further patch extraction.
+    // Thanks to the reference counting, "temp" mat (the pyramid layer + border)
+    // will not be deallocated, since {prevPyr|nextPyr}[level] will be a ROI in "temp".
+    for( k = 0; k < 2; k++ )
+    {
+        Size sz = prevImg.size();
+        vector<Mat>& pyr = k == 0 ? prevPyr : nextPyr;
+        Mat& img0 = k == 0 ? prevImg : nextImg;
+        
+        for( level = 0; level <= maxLevel; level++ )
+        {
+            Mat temp(sz.height + winSize.height*2,
+                     sz.width + winSize.width*2,
+                     img0.type());
+            pyr[level] = temp(Rect(winSize.width, winSize.height, sz.width, sz.height));
+            if( level == 0 )
+                img0.copyTo(pyr[level]);
+            else
+                pyrDown(pyr[level-1], pyr[level], pyr[level].size());
+            copyMakeBorder(pyr[level], temp, winSize.height, winSize.height,
+                           winSize.width, winSize.width, BORDER_REFLECT_101);
+            sz = Size((sz.width+1)/2, (sz.height+1)/2);
+            if( sz.width <= winSize.width || sz.height <= winSize.height )
+            {
+                maxLevel = level;
+                break;
+            }
+        }
+    }
+    // dI/dx ~ Ix, dI/dy ~ Iy
     Mat derivIBuf((prevImg.rows + winSize.height*2),
-                  (prevImg.cols + winSize.width*2),
-                  CV_MAKETYPE(derivDepth, cn*6));
-    // J, dJ/dx ~ Jx, dJ/dy ~ Jy
-    Mat derivJBuf((prevImg.rows + winSize.height*2),
-                  (prevImg.cols + winSize.width*2),
-                  CV_MAKETYPE(derivDepth, cn*3));
-    Mat tempDerivBuf(prevImg.size(), CV_MAKETYPE(derivIBuf.type(), cn));
-    Mat derivIWinBuf(winSize, derivIBuf.type());
+             (prevImg.cols + winSize.width*2),
+             CV_MAKETYPE(derivDepth, cn2));
 
     if( (criteria.type & TermCriteria::COUNT) == 0 )
         criteria.maxCount = 30;
@@ -130,260 +599,25 @@ void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
         criteria.epsilon = std::min(std::max(criteria.epsilon, 0.), 10.);
     criteria.epsilon *= criteria.epsilon;
 
-    for( int level = maxLevel; level >= 0; level-- )
+    for( level = maxLevel; level >= 0; level-- )
     {
-        int k;
         Size imgSize = prevPyr[level].size();
-        Mat tempDeriv( imgSize, tempDerivBuf.type(), tempDerivBuf.data );
         Mat _derivI( imgSize.height + winSize.height*2,
-            imgSize.width + winSize.width*2,
-            derivIBuf.type(), derivIBuf.data );
-        Mat _derivJ( imgSize.height + winSize.height*2,
-            imgSize.width + winSize.width*2,
-            derivJBuf.type(), derivJBuf.data );
-        Mat derivI(_derivI, Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
-        Mat derivJ(_derivJ, Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
-        CvMat cvderivI = _derivI;
-        cvZero(&cvderivI);
-        CvMat cvderivJ = _derivJ;
-        cvZero(&cvderivJ);
-
-        vector<int> fromTo(cn*2);
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2] = k;
-
-        prevPyr[level].convertTo(tempDeriv, derivDepth);
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        // compute spatial derivatives and merge them together
-        Sobel(prevPyr[level], tempDeriv, derivDepth, 1, 0, derivKernelSize, deriv1Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6 + 1;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        Sobel(prevPyr[level], tempDeriv, derivDepth, 0, 1, derivKernelSize, deriv1Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6 + 2;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        Sobel(prevPyr[level], tempDeriv, derivDepth, 2, 0, derivKernelSize, deriv2Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6 + 3;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        Sobel(prevPyr[level], tempDeriv, derivDepth, 1, 1, derivKernelSize, deriv2Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6 + 4;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        Sobel(prevPyr[level], tempDeriv, derivDepth, 0, 2, derivKernelSize, deriv2Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*6 + 5;
-        mixChannels(&tempDeriv, 1, &derivI, 1, &fromTo[0], cn);
-
-        nextPyr[level].convertTo(tempDeriv, derivDepth);
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*3;
-        mixChannels(&tempDeriv, 1, &derivJ, 1, &fromTo[0], cn);
-
-        Sobel(nextPyr[level], tempDeriv, derivDepth, 1, 0, derivKernelSize, deriv1Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*3 + 1;
-        mixChannels(&tempDeriv, 1, &derivJ, 1, &fromTo[0], cn);
-
-        Sobel(nextPyr[level], tempDeriv, derivDepth, 0, 1, derivKernelSize, deriv1Scale );
-        for( k = 0; k < cn; k++ )
-            fromTo[k*2+1] = k*3 + 2;
-        mixChannels(&tempDeriv, 1, &derivJ, 1, &fromTo[0], cn);
-
-        /*copyMakeBorder( derivI, _derivI, winSize.height, winSize.height,
-            winSize.width, winSize.width, BORDER_CONSTANT );
-        copyMakeBorder( derivJ, _derivJ, winSize.height, winSize.height,
-            winSize.width, winSize.width, BORDER_CONSTANT );*/
-
-        for( int ptidx = 0; ptidx < npoints; ptidx++ )
-        {
-            Point2f prevPt = prevPts[ptidx]*(float)(1./(1 << level));
-            Point2f nextPt;
-            if( level == maxLevel )
-            {
-                if( flags & OPTFLOW_USE_INITIAL_FLOW )
-                    nextPt = nextPts[ptidx]*(float)(1./(1 << level));
-                else
-                    nextPt = prevPt;
-            }
-            else
-                nextPt = nextPts[ptidx]*2.f;
-            nextPts[ptidx] = nextPt;
-            
-            Point2i iprevPt, inextPt;
-            prevPt -= halfWin;
-            iprevPt.x = cvFloor(prevPt.x);
-            iprevPt.y = cvFloor(prevPt.y);
-
-            if( iprevPt.x < -winSize.width || iprevPt.x >= derivI.cols ||
-                iprevPt.y < -winSize.height || iprevPt.y >= derivI.rows )
-            {
-                if( level == 0 )
-                {
-                    status[ptidx] = false;
-                    err[ptidx] = FLT_MAX;
-                }
-                continue;
-            }
-            
-            float a = prevPt.x - iprevPt.x;
-            float b = prevPt.y - iprevPt.y;
-            float w00 = (1.f - a)*(1.f - b), w01 = a*(1.f - b);
-            float w10 = (1.f - a)*b, w11 = a*b;
-            size_t stepI = derivI.step/derivI.elemSize1();
-            size_t stepJ = derivJ.step/derivJ.elemSize1();
-            int cnI = cn*6, cnJ = cn*3;
-            double A11 = 0, A12 = 0, A22 = 0;
-            double iA11 = 0, iA12 = 0, iA22 = 0;
-            
-            // extract the patch from the first image
-            int x, y;
-            for( y = 0; y < winSize.height; y++ )
-            {
-                const float* src = (const float*)(derivI.data +
-                    (y + iprevPt.y)*derivI.step) + iprevPt.x*cnI;
-                float* dst = (float*)(derivIWinBuf.data + y*derivIWinBuf.step);
-
-                for( x = 0; x < winSize.width*cnI; x += cnI, src += cnI )
-                {
-                    float I = src[0]*w00 + src[cnI]*w01 + src[stepI]*w10 + src[stepI+cnI]*w11;
-                    dst[x] = I;
-                    
-                    float Ix = src[1]*w00 + src[cnI+1]*w01 + src[stepI+1]*w10 + src[stepI+cnI+1]*w11;
-                    float Iy = src[2]*w00 + src[cnI+2]*w01 + src[stepI+2]*w10 + src[stepI+cnI+2]*w11;
-                    dst[x+1] = Ix; dst[x+2] = Iy;
-                    
-                    float Ixx = src[3]*w00 + src[cnI+3]*w01 + src[stepI+3]*w10 + src[stepI+cnI+3]*w11;
-                    float Ixy = src[4]*w00 + src[cnI+4]*w01 + src[stepI+4]*w10 + src[stepI+cnI+4]*w11;
-                    float Iyy = src[5]*w00 + src[cnI+5]*w01 + src[stepI+5]*w10 + src[stepI+cnI+5]*w11;
-                    dst[x+3] = Ixx; dst[x+4] = Ixy; dst[x+5] = Iyy;
-
-                    iA11 += (double)Ix*Ix;
-                    iA12 += (double)Ix*Iy;
-                    iA22 += (double)Iy*Iy;
-
-                    A11 += (double)Ixx*Ixx + (double)Ixy*Ixy;
-                    A12 += Ixy*((double)Ixx + Iyy);
-                    A22 += (double)Ixy*Ixy + (double)Iyy*Iyy;
-                }
-            }
-
-            A11 = lambda1*iA11 + lambda2*A11;
-            A12 = lambda1*iA12 + lambda2*A12;
-            A22 = lambda1*iA22 + lambda2*A22;
-
-            double D = A11*A22 - A12*A12;
-            double minEig = (A22 + A11 - std::sqrt((A11-A22)*(A11-A22) +
-                4.*A12*A12))/(2*winSize.width*winSize.height);
-            if( err )
-                err[ptidx] = (float)minEig;
-
-            if( D < DBL_EPSILON )
-            {
-                if( level == 0 )
-                    status[ptidx] = false;
-                continue;
-            }
-            
-            D = 1./D;
-
-            nextPt -= halfWin;
-            Point2f prevDelta;
-
-            for( int j = 0; j < criteria.maxCount; j++ )
-            {
-                inextPt.x = cvFloor(nextPt.x);
-                inextPt.y = cvFloor(nextPt.y);
-
-                if( inextPt.x < -winSize.width || inextPt.x >= derivJ.cols ||
-                    inextPt.y < -winSize.height || inextPt.y >= derivJ.rows )
-                {
-                    if( level == 0 )
-                        status[ptidx] = false;
-                    break;
-                }
-
-                a = nextPt.x - inextPt.x;
-                b = nextPt.y - inextPt.y;
-                w00 = (1.f - a)*(1.f - b); w01 = a*(1.f - b);
-                w10 = (1.f - a)*b; w11 = a*b;
-
-                double b1 = 0, b2 = 0, ib1 = 0, ib2 = 0;
-
-                for( y = 0; y < winSize.height; y++ )
-                {
-                    const float* src = (const float*)(derivJ.data +
-                        (y + inextPt.y)*derivJ.step) + inextPt.x*cnJ;
-                    const float* Ibuf = (float*)(derivIWinBuf.data + y*derivIWinBuf.step);
-
-                    for( x = 0; x < winSize.width; x++, src += cnJ, Ibuf += cnI )
-                    {
-                        double It = src[0]*w00 + src[cnJ]*w01 + src[stepJ]*w10 +
-                                    src[stepJ+cnJ]*w11 - Ibuf[0];
-                        double Ixt = src[1]*w00 + src[cnJ+1]*w01 + src[stepJ+1]*w10 +
-                                     src[stepJ+cnJ+1]*w11 - Ibuf[1];
-                        double Iyt = src[2]*w00 + src[cnJ+2]*w01 + src[stepJ+2]*w10 +
-                                     src[stepJ+cnJ+2]*w11 - Ibuf[2];
-                        b1 += Ixt*Ibuf[3] + Iyt*Ibuf[4];
-                        b2 += Ixt*Ibuf[4] + Iyt*Ibuf[5];
-                        ib1 += It*Ibuf[1];
-                        ib2 += It*Ibuf[2];
-                    }
-                }
-
-                b1 = lambda1*ib1 + lambda2*b1;
-                b2 = lambda1*ib2 + lambda2*b2;
-                Point2f delta( (float)((A12*b2 - A22*b1) * D),
-                               (float)((A12*b1 - A11*b2) * D));
-                //delta = -delta;
-
-                nextPt += delta;
-                nextPts[ptidx] = nextPt + halfWin;
-
-                if( delta.ddot(delta) <= criteria.epsilon )
-                    break;
-
-                if( j > 0 && std::abs(delta.x + prevDelta.x) < 0.01 &&
-                    std::abs(delta.y + prevDelta.y) < 0.01 )
-                {
-                    nextPts[ptidx] -= delta*0.5f;
-                    break;
-                }
-                prevDelta = delta;
-            }
-        }
+            imgSize.width + winSize.width*2, derivIBuf.type(), derivIBuf.data );
+        Mat derivI = _derivI(Rect(winSize.width, winSize.height, imgSize.width, imgSize.height));
+        calcSharrDeriv(prevPyr[level], derivI);
+        copyMakeBorder(derivI, _derivI, winSize.height, winSize.height, winSize.width, winSize.width, BORDER_CONSTANT);
+        
+        Mat I = prevPyr[level], J = nextPyr[level];
+        
+        parallel_for(BlockedRange(0, npoints), LKTrackerInvoker(prevPyr[level], derivI,
+                                                                nextPyr[level], prevPts, nextPts,
+                                                                status, err,
+                                                                winSize, criteria, level, maxLevel,
+                                                                flags, (float)minEigThreshold));
     }
 }
 
-static void
-intersect( CvPoint2D32f pt, CvSize win_size, CvSize imgSize,
-           CvPoint* min_pt, CvPoint* max_pt )
-{
-    CvPoint ipt;
-
-    ipt.x = cvFloor( pt.x );
-    ipt.y = cvFloor( pt.y );
-
-    ipt.x -= win_size.width;
-    ipt.y -= win_size.height;
-
-    win_size.width = win_size.width * 2 + 1;
-    win_size.height = win_size.height * 2 + 1;
-
-    min_pt->x = MAX( 0, -ipt.x );
-    min_pt->y = MAX( 0, -ipt.y );
-    max_pt->x = MIN( win_size.width, imgSize.width - ipt.x );
-    max_pt->y = MIN( win_size.height, imgSize.height - ipt.y );
-}
-
 
 static int icvMinimalPyramidSize( CvSize imgSize )
 {
@@ -815,362 +1049,31 @@ return CV_OK;                                                           \
 
 ICV_DEF_GET_QUADRANGLE_SUB_PIX_FUNC( 8u32f, uchar, float, double, CV_CAST_32F, CV_8TO32F )
 
-namespace cv
-{
-
-struct LKTrackerInvoker
-{
-    LKTrackerInvoker( const CvMat* _imgI, const CvMat* _imgJ,
-                      const CvPoint2D32f* _featuresA,
-                      CvPoint2D32f* _featuresB,
-                      char* _status, float* _error,
-                      CvTermCriteria _criteria,
-                      CvSize _winSize, int _level, int _flags )
-    {
-        imgI = _imgI;
-        imgJ = _imgJ;
-        featuresA = _featuresA;
-        featuresB = _featuresB;
-        status = _status;
-        error = _error;
-        criteria = _criteria;
-        winSize = _winSize;
-        level = _level;
-        flags = _flags;
-    }
-    
-    void operator()(const BlockedRange& range) const
-    {
-        static const float smoothKernel[] = { 0.09375, 0.3125, 0.09375 };  // 3/32, 10/32, 3/32
-        
-        int i, i1 = range.begin(), i2 = range.end();
-        
-        CvSize patchSize = cvSize( winSize.width * 2 + 1, winSize.height * 2 + 1 );
-        int patchLen = patchSize.width * patchSize.height;
-        int srcPatchLen = (patchSize.width + 2)*(patchSize.height + 2);
-        
-        AutoBuffer<float> buf(patchLen*3 + srcPatchLen);
-        float* patchI = buf;
-        float* patchJ = patchI + srcPatchLen;
-        float* Ix = patchJ + patchLen;
-        float* Iy = Ix + patchLen;
-        float scaleL = 1.f/(1 << level);
-        CvSize levelSize = cvGetMatSize(imgI);
-        
-        // find flow for each given point
-        for( i = i1; i < i2; i++ )
-        {
-            CvPoint2D32f v;
-            CvPoint minI, maxI, minJ, maxJ;
-            CvSize isz, jsz;
-            int pt_status;
-            CvPoint2D32f u;
-            CvPoint prev_minJ = { -1, -1 }, prev_maxJ = { -1, -1 };
-            double Gxx = 0, Gxy = 0, Gyy = 0, D = 0, minEig = 0;
-            float prev_mx = 0, prev_my = 0;
-            int j, x, y;
-            
-            v.x = featuresB[i].x*2;
-            v.y = featuresB[i].y*2;
-            
-            pt_status = status[i];
-            if( !pt_status )
-                continue;
-            
-            minI = maxI = minJ = maxJ = cvPoint(0, 0);
-            
-            u.x = featuresA[i].x * scaleL;
-            u.y = featuresA[i].y * scaleL;
-            
-            intersect( u, winSize, levelSize, &minI, &maxI );
-            isz = jsz = cvSize(maxI.x - minI.x + 2, maxI.y - minI.y + 2);
-            u.x += (minI.x - (patchSize.width - maxI.x + 1))*0.5f;
-            u.y += (minI.y - (patchSize.height - maxI.y + 1))*0.5f;
-            
-            if( isz.width < 3 || isz.height < 3 ||
-                icvGetRectSubPix_8u32f_C1R( imgI->data.ptr, imgI->step, levelSize,
-                                            patchI, isz.width*sizeof(patchI[0]), isz, u ) < 0 )
-            {
-                // point is outside the first image. take the next
-                status[i] = 0;
-                continue;
-            }
-            
-            icvCalcIxIy_32f( patchI, isz.width*sizeof(patchI[0]), Ix, Iy,
-                             (isz.width-2)*sizeof(patchI[0]), isz, smoothKernel, patchJ );
-            
-            for( j = 0; j < criteria.max_iter; j++ )
-            {
-                double bx = 0, by = 0;
-                float mx, my;
-                CvPoint2D32f _v;
-                
-                intersect( v, winSize, levelSize, &minJ, &maxJ );
-                
-                minJ.x = MAX( minJ.x, minI.x );
-                minJ.y = MAX( minJ.y, minI.y );
-                
-                maxJ.x = MIN( maxJ.x, maxI.x );
-                maxJ.y = MIN( maxJ.y, maxI.y );
-                
-                jsz = cvSize(maxJ.x - minJ.x, maxJ.y - minJ.y);
-                
-                _v.x = v.x + (minJ.x - (patchSize.width - maxJ.x + 1))*0.5f;
-                _v.y = v.y + (minJ.y - (patchSize.height - maxJ.y + 1))*0.5f;
-                
-                if( jsz.width < 1 || jsz.height < 1 ||
-                    icvGetRectSubPix_8u32f_C1R( imgJ->data.ptr, imgJ->step, levelSize, patchJ,
-                                                jsz.width*sizeof(patchJ[0]), jsz, _v ) < 0 )
-                {
-                    // point is outside of the second image. take the next
-                    pt_status = 0;
-                    break;
-                }
-                
-                if( maxJ.x == prev_maxJ.x && maxJ.y == prev_maxJ.y &&
-                    minJ.x == prev_minJ.x && minJ.y == prev_minJ.y )
-                {
-                    for( y = 0; y < jsz.height; y++ )
-                    {
-                        const float* pi = patchI +
-                        (y + minJ.y - minI.y + 1)*isz.width + minJ.x - minI.x + 1;
-                        const float* pj = patchJ + y*jsz.width;
-                        const float* ix = Ix +
-                        (y + minJ.y - minI.y)*(isz.width-2) + minJ.x - minI.x;
-                        const float* iy = Iy + (ix - Ix);
-                        
-                        for( x = 0; x < jsz.width; x++ )
-                        {
-                            double t0 = pi[x] - pj[x];
-                            bx += t0 * ix[x];
-                            by += t0 * iy[x];
-                        }
-                    }
-                }
-                else
-                {
-                    Gxx = Gyy = Gxy = 0;
-                    for( y = 0; y < jsz.height; y++ )
-                    {
-                        const float* pi = patchI +
-                        (y + minJ.y - minI.y + 1)*isz.width + minJ.x - minI.x + 1;
-                        const float* pj = patchJ + y*jsz.width;
-                        const float* ix = Ix +
-                        (y + minJ.y - minI.y)*(isz.width-2) + minJ.x - minI.x;
-                        const float* iy = Iy + (ix - Ix);
-                        
-                        for( x = 0; x < jsz.width; x++ )
-                        {
-                            double t = pi[x] - pj[x];
-                            bx += (double) (t * ix[x]);
-                            by += (double) (t * iy[x]);
-                            Gxx += ix[x] * ix[x];
-                            Gxy += ix[x] * iy[x];
-                            Gyy += iy[x] * iy[x];
-                        }
-                    }
-                    
-                    D = Gxx * Gyy - Gxy * Gxy;
-                    if( D < DBL_EPSILON )
-                    {
-                        pt_status = 0;
-                        break;
-                    }
-                    
-                    // Adi Shavit - 2008.05
-                    if( flags & CV_LKFLOW_GET_MIN_EIGENVALS )
-                        minEig = (Gyy + Gxx - sqrt((Gxx-Gyy)*(Gxx-Gyy) + 4.*Gxy*Gxy))/(2*jsz.height*jsz.width);
-                        
-                    D = 1. / D;
-                        
-                    prev_minJ = minJ;
-                    prev_maxJ = maxJ;
-                }
-                
-                mx = (float) ((Gyy * bx - Gxy * by) * D);
-                my = (float) ((Gxx * by - Gxy * bx) * D);
-                
-                v.x += mx;
-                v.y += my;
-                
-                if( mx * mx + my * my < criteria.epsilon )
-                    break;
-                
-                if( j > 0 && fabs(mx + prev_mx) < 0.01 && fabs(my + prev_my) < 0.01 )
-                {
-                    v.x -= mx*0.5f;
-                    v.y -= my*0.5f;
-                    break;
-                }
-                prev_mx = mx;
-                prev_my = my;
-            }
-            
-            featuresB[i] = v;
-            status[i] = (char)pt_status;
-            if( level == 0 && error && pt_status )
-            {
-                // calc error
-                double err = 0;
-                if( flags & CV_LKFLOW_GET_MIN_EIGENVALS )
-                    err = minEig;
-                else
-                {
-                    for( y = 0; y < jsz.height; y++ )
-                    {
-                        const float* pi = patchI +
-                        (y + minJ.y - minI.y + 1)*isz.width + minJ.x - minI.x + 1;
-                        const float* pj = patchJ + y*jsz.width;
-                        
-                        for( x = 0; x < jsz.width; x++ )
-                        {
-                            double t = pi[x] - pj[x];
-                            err += t * t;
-                        }
-                    }
-                    err = sqrt(err);
-                }
-                error[i] = (float)err;
-            }
-        } // end of point processing loop (i)
-    }
-    
-    const CvMat* imgI;
-    const CvMat* imgJ;
-    const CvPoint2D32f* featuresA;
-    CvPoint2D32f* featuresB;
-    char* status;
-    float* error;
-    CvTermCriteria criteria;
-    CvSize winSize;
-    int level;
-    int flags;
-};
-    
-    
-}
-
 
 CV_IMPL void
 cvCalcOpticalFlowPyrLK( const void* arrA, const void* arrB,
-                        void* pyrarrA, void* pyrarrB,
+                        void* /*pyrarrA*/, void* /*pyrarrB*/,
                         const CvPoint2D32f * featuresA,
                         CvPoint2D32f * featuresB,
                         int count, CvSize winSize, int level,
                         char *status, float *error,
                         CvTermCriteria criteria, int flags )
 {
-    cv::AutoBuffer<uchar> pyrBuffer;
-    cv::AutoBuffer<uchar> buffer;
-    cv::AutoBuffer<char> _status;
-
-    const int MAX_ITERS = 100;
-
-    CvMat stubA, *imgA = (CvMat*)arrA;
-    CvMat stubB, *imgB = (CvMat*)arrB;
-    CvMat pstubA, *pyrA = (CvMat*)pyrarrA;
-    CvMat pstubB, *pyrB = (CvMat*)pyrarrB;
-    CvSize imgSize;
-    
-    uchar **imgI = 0;
-    uchar **imgJ = 0;
-    int *step = 0;
-    double *scale = 0;
-    CvSize* size = 0;
-
-    int i, l;
-
-    imgA = cvGetMat( imgA, &stubA );
-    imgB = cvGetMat( imgB, &stubB );
-
-    if( CV_MAT_TYPE( imgA->type ) != CV_8UC1 )
-        CV_Error( CV_StsUnsupportedFormat, "" );
-
-    if( !CV_ARE_TYPES_EQ( imgA, imgB ))
-        CV_Error( CV_StsUnmatchedFormats, "" );
-
-    if( !CV_ARE_SIZES_EQ( imgA, imgB ))
-        CV_Error( CV_StsUnmatchedSizes, "" );
-
-    if( imgA->step != imgB->step )
-        CV_Error( CV_StsUnmatchedSizes, "imgA and imgB must have equal steps" );
-
-    imgSize = cvGetMatSize( imgA );
-
-    if( pyrA )
-    {
-        pyrA = cvGetMat( pyrA, &pstubA );
-
-        if( pyrA->step*pyrA->height < icvMinimalPyramidSize( imgSize ) )
-            CV_Error( CV_StsBadArg, "pyramid A has insufficient size" );
-    }
-    else
-    {
-        pyrA = &pstubA;
-        pyrA->data.ptr = 0;
-    }
-
-    if( pyrB )
-    {
-        pyrB = cvGetMat( pyrB, &pstubB );
-
-        if( pyrB->step*pyrB->height < icvMinimalPyramidSize( imgSize ) )
-            CV_Error( CV_StsBadArg, "pyramid B has insufficient size" );
-    }
-    else
-    {
-        pyrB = &pstubB;
-        pyrB->data.ptr = 0;
-    }
-
-    if( count == 0 )
+    if( count <= 0 )
         return;
-
-    if( !featuresA || !featuresB )
-        CV_Error( CV_StsNullPtr, "Some of arrays of point coordinates are missing" );
-
-    if( count < 0 )
-        CV_Error( CV_StsOutOfRange, "The number of tracked points is negative or zero" );
-
-    if( winSize.width <= 1 || winSize.height <= 1 )
-        CV_Error( CV_StsBadSize, "Invalid search window size" );
-
-    icvInitPyramidalAlgorithm( imgA, imgB, pyrA, pyrB,
-        level, &criteria, MAX_ITERS, flags,
-        &imgI, &imgJ, &step, &size, &scale, &pyrBuffer );
-
-    if( !status )
-    {
-        _status.allocate(count);
-        status = _status;
-    }
-
-    memset( status, 1, count );
-    if( error )
-        memset( error, 0, count*sizeof(error[0]) );
-
-    if( !(flags & CV_LKFLOW_INITIAL_GUESSES) )
-        memcpy( featuresB, featuresA, count*sizeof(featuresA[0]));
+    CV_Assert( featuresA && featuresB );
+    cv::Mat A = cv::cvarrToMat(arrA), B = cv::cvarrToMat(arrB);
+    cv::Mat ptA(count, 1, CV_32FC2, (void*)featuresA);
+    cv::Mat ptB(count, 1, CV_32FC2, (void*)featuresB);
+    cv::Mat st, err;
     
-    for( i = 0; i < count; i++ )
-    {
-        featuresB[i].x = (float)(featuresB[i].x * scale[level] * 0.5);
-        featuresB[i].y = (float)(featuresB[i].y * scale[level] * 0.5);
-    }
-
-    /* do processing from top pyramid level (smallest image)
-       to the bottom (original image) */
-    for( l = level; l >= 0; l-- )
-    {
-        CvMat imgI_l, imgJ_l;        
-        cvInitMatHeader(&imgI_l, size[l].height, size[l].width, imgA->type, imgI[l], step[l]);
-        cvInitMatHeader(&imgJ_l, size[l].height, size[l].width, imgB->type, imgJ[l], step[l]);
-        
-        cv::parallel_for(cv::BlockedRange(0, count),
-                         cv::LKTrackerInvoker(&imgI_l, &imgJ_l, featuresA,
-                                              featuresB, status, error,
-                                              criteria, winSize, l, flags));
-    } // end of pyramid levels loop (l)
+    if( status )
+        st = cv::Mat(count, 1, CV_8U, (void*)status);
+    if( error )
+        err = cv::Mat(count, 1, CV_32F, (void*)error);
+    cv::calcOpticalFlowPyrLK( A, B, ptA, ptB, status ? cv::_OutputArray(st) : cv::_OutputArray(),
+                              error ? cv::_OutputArray(err) : cv::_OutputArray(),
+                              winSize, level, criteria, flags);
 }
 
 
diff --git a/modules/video/test/test_accum.cpp b/modules/video/test/test_accum.cpp
index d3cab6cb63..52dbf0e3be 100644
--- a/modules/video/test/test_accum.cpp
+++ b/modules/video/test/test_accum.cpp
@@ -73,7 +73,7 @@ void CV_AccumBaseTest::get_test_array_types_and_sizes( int test_case_idx,
     RNG& rng = ts->get_rng();
     int depth = cvtest::randInt(rng) % 3, cn = cvtest::randInt(rng) & 1 ? 3 : 1;
     int accdepth = std::max((int)(cvtest::randInt(rng) % 2 + 1), depth);
-    int i, input_count = test_array[INPUT].size();
+    int i, input_count = (int)test_array[INPUT].size();
     cvtest::ArrayTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
     depth = depth == 0 ? CV_8U : depth == 1 ? CV_32F : CV_64F;
     accdepth = accdepth == 1 ? CV_32F : CV_64F;
diff --git a/modules/video/test/test_optflowpyrlk.cpp b/modules/video/test/test_optflowpyrlk.cpp
index b7ed60dfde..ef517fac99 100644
--- a/modules/video/test/test_optflowpyrlk.cpp
+++ b/modules/video/test/test_optflowpyrlk.cpp
@@ -58,8 +58,8 @@ void CV_OptFlowPyrLKTest::run( int )
 {
     int code = cvtest::TS::OK;
 
-    const double success_error_level = 0.2;
-    const int bad_points_max = 2;
+    const double success_error_level = 0.3;
+    const int bad_points_max = 8;
 
     /* test parameters */
     double  max_err = 0., sum_err = 0;
@@ -139,7 +139,7 @@ void CV_OptFlowPyrLKTest::run( int )
     status = (char*)cvAlloc(n*sizeof(status[0]));
 
     /* calculate flow */
-    cvCalcOpticalFlowPyrLK( imgI, imgJ, 0, 0, u, v2, n, cvSize( 20, 20 ),
+    cvCalcOpticalFlowPyrLK( imgI, imgJ, 0, 0, u, v2, n, cvSize( 41, 41 ),
                             4, status, 0, cvTermCriteria( CV_TERMCRIT_ITER|
                             CV_TERMCRIT_EPS, 30, 0.01f ), 0 );
 
@@ -163,14 +163,6 @@ void CV_OptFlowPyrLKTest::run( int )
             }
 
             pt_exceed += err > success_error_level;
-            if( pt_exceed > bad_points_max )
-            {
-                ts->printf( cvtest::TS::LOG,
-                    "The number of poorly tracked points is too big (>=%d)\n", pt_exceed );
-                code = cvtest::TS::FAIL_BAD_ACCURACY;
-                goto _exit_;
-            }
-
             sum_err += err;
             pt_cmpd++;
         }
@@ -186,6 +178,14 @@ void CV_OptFlowPyrLKTest::run( int )
             }
         }
     }
+    
+    if( pt_exceed > bad_points_max )
+    {
+        ts->printf( cvtest::TS::LOG,
+                   "The number of poorly tracked points is too big (>=%d)\n", pt_exceed );
+        code = cvtest::TS::FAIL_BAD_ACCURACY;
+        goto _exit_;
+    }
 
     if( max_err > 1 )
     {
diff --git a/opencv-XXX.pc.cmake.in b/opencv-XXX.pc.cmake.in
new file mode 100644
index 0000000000..4f6415cab4
--- /dev/null
+++ b/opencv-XXX.pc.cmake.in
@@ -0,0 +1,13 @@
+# Package Information for pkg-config
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir_old=@includedir@/opencv
+includedir_new=@includedir@
+
+Name: OpenCV
+Description: Open Source Computer Vision Library
+Version: @VERSION@
+Libs: @OpenCV_LIB_COMPONENTS@
+Cflags: -I${includedir_old} -I${includedir_new}
diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt
index 1a601589a9..3bd7b32de7 100644
--- a/samples/CMakeLists.txt
+++ b/samples/CMakeLists.txt
@@ -5,7 +5,14 @@
 
 add_subdirectory(c)
 add_subdirectory(cpp)
-add_subdirectory(gpu)
+
+if(NOT ANDROID)
+    add_subdirectory(gpu)
+endif()
+
+if(BUILD_ANDROID_EXAMPLES)
+   add_subdirectory(android)
+endif()
 
 if(0)
 add_subdirectory(swig_python)
diff --git a/samples/android/15-puzzle/.classpath b/samples/android/15-puzzle/.classpath
new file mode 100644
index 0000000000..87ce3fa5d8
--- /dev/null
+++ b/samples/android/15-puzzle/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/15-puzzle/.project b/samples/android/15-puzzle/.project
new file mode 100644
index 0000000000..9005e16179
--- /dev/null
+++ b/samples/android/15-puzzle/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Sample - 15-puzzle</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/15-puzzle/.settings/org.eclipse.jdt.core.prefs b/samples/android/15-puzzle/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/15-puzzle/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/15-puzzle/AndroidManifest.xml b/samples/android/15-puzzle/AndroidManifest.xml
new file mode 100644
index 0000000000..30003c1f98
--- /dev/null
+++ b/samples/android/15-puzzle/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.puzzle15"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <application android:icon="@drawable/icon" android:label="@string/app_name">
+        <activity android:name=".puzzle15Activity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+</manifest>
\ No newline at end of file
diff --git a/samples/android/15-puzzle/default.properties b/samples/android/15-puzzle/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/samples/android/15-puzzle/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/android/apps/OpenCV_SAMPLE/res/drawable-hdpi/icon.png b/samples/android/15-puzzle/res/drawable/icon.png
similarity index 100%
rename from android/apps/OpenCV_SAMPLE/res/drawable-hdpi/icon.png
rename to samples/android/15-puzzle/res/drawable/icon.png
diff --git a/samples/android/15-puzzle/res/values/strings.xml b/samples/android/15-puzzle/res/values/strings.xml
new file mode 100644
index 0000000000..35902fd9af
--- /dev/null
+++ b/samples/android/15-puzzle/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Sample - 15-puzzle</string>
+</resources>
diff --git a/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/SampleCvViewBase.java b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/SampleCvViewBase.java
new file mode 100644
index 0000000000..d1f908147c
--- /dev/null
+++ b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/SampleCvViewBase.java
@@ -0,0 +1,110 @@
+package org.opencv.samples.puzzle15;
+
+import java.util.List;
+
+import org.opencv.core.Size;
+import org.opencv.highgui.VideoCapture;
+import org.opencv.highgui.Highgui;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private SurfaceHolder       mHolder;
+    private VideoCapture        mCamera;
+
+    public SampleCvViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        synchronized (this) {
+            if (mCamera != null && mCamera.isOpened()) {
+                Log.i(TAG, "before mCamera.getSupportedPreviewSizes()");
+                List<Size> sizes = mCamera.getSupportedPreviewSizes();
+                Log.i(TAG, "after mCamera.getSupportedPreviewSizes()");
+                int mFrameWidth = width;
+                int mFrameHeight = height;
+
+                // selecting optimal camera preview size
+                {
+                    double minDiff = Double.MAX_VALUE;
+                    for (Size size : sizes) {
+                        if (Math.abs(size.height - height) < minDiff) {
+                            mFrameWidth = (int) size.width;
+                            mFrameHeight = (int) size.height;
+                            minDiff = Math.abs(size.height - height);
+                        }
+                    }
+                }
+
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
+            }
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+        if (mCamera.isOpened()) {
+            (new Thread(this)).start();
+        } else {
+            mCamera.release();
+            mCamera = null;
+            Log.e(TAG, "Failed to open native camera");
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(VideoCapture capture);
+
+    public void run() {
+        Log.i(TAG, "Starting processing thread");
+        while (true) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                if (mCamera == null)
+                    break;
+
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "mCamera.grab() failed");
+                    break;
+                }
+
+                bmp = processFrame(mCamera);
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+
+        Log.i(TAG, "Finishing processing thread");
+    }
+}
\ No newline at end of file
diff --git a/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15Activity.java b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15Activity.java
new file mode 100644
index 0000000000..2444f5755a
--- /dev/null
+++ b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15Activity.java
@@ -0,0 +1,50 @@
+package org.opencv.samples.puzzle15;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class puzzle15Activity extends Activity {
+    private static final String TAG = "Sample::Activity";
+
+    private MenuItem            mItemNewGame;
+    private MenuItem            mItemToggleNumbers;
+    private puzzle15View        mView;
+
+    public puzzle15Activity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        mView = new puzzle15View(this);
+        setContentView(mView);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemNewGame = menu.add("Start new game");
+        mItemToggleNumbers = menu.add("Show/hide tile numbers");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemNewGame) {
+            synchronized (mView) {
+                mView.startNewGame();
+            }
+        } else if (item == mItemToggleNumbers)
+            mView.tolggleTileNumbers();
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15View.java b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15View.java
new file mode 100644
index 0000000000..a4d18ae71f
--- /dev/null
+++ b/samples/android/15-puzzle/src/org/opencv/samples/puzzle15/puzzle15View.java
@@ -0,0 +1,227 @@
+package org.opencv.samples.puzzle15;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.MotionEvent;
+import android.view.SurfaceHolder;
+import android.view.View;
+import android.view.View.OnTouchListener;
+
+public class puzzle15View extends SampleCvViewBase implements OnTouchListener {
+    private Mat     mRgba;
+    private Mat     mRgba15;
+    private Mat[]   mCells;
+    private Mat[]   mCells15;
+    private int[]   mIndexses;
+    private int[]   mTextWidths;
+    private int[]   mTextHeights;
+    private boolean mShowTileNumbers = true;
+
+    int             gridSize         = 4;
+    int             gridArea         = gridSize * gridSize;
+    int             gridEmptyIdx     = gridArea - 1;
+
+    public puzzle15View(Context context) {
+        super(context);
+        setOnTouchListener(this);
+
+        mTextWidths = new int[gridArea];
+        mTextHeights = new int[gridArea];
+        for (int i = 0; i < gridArea; i++) {
+            Size s = Core.getTextSize(Integer.toString(i + 1), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, 2, null);
+            mTextHeights[i] = (int) s.height;
+            mTextWidths[i] = (int) s.width;
+        }
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+        synchronized (this) {
+            // initialize Mat before usage
+            mRgba = new Mat();
+        }
+    }
+
+    public static void shuffle(int[] array) {
+        for (int i = array.length; i > 1; i--) {
+            int temp = array[i - 1];
+            int randIx = (int) (Math.random() * i);
+            array[i - 1] = array[randIx];
+            array[randIx] = temp;
+        }
+    }
+
+    public boolean isPuzzleSolvable() {
+        if (gridSize != 4)
+            return true;
+
+        int sum = 0;
+        for (int i = 0; i < gridArea; i++) {
+            if (mIndexses[i] == gridEmptyIdx)
+                sum += (i / gridSize) + 1;
+            else {
+                int smaller = 0;
+                for (int j = i + 1; j < gridArea; j++) {
+                    if (mIndexses[j] < mIndexses[i])
+                        smaller++;
+                }
+                sum += smaller;
+            }
+        }
+
+        return sum % 2 == 0;
+    }
+
+    private void createPuzzle(int cols, int rows) {
+        mCells = new Mat[gridArea];
+        mCells15 = new Mat[gridArea];
+
+        mRgba15 = new Mat(rows, cols, mRgba.type());
+        mIndexses = new int[gridArea];
+
+        for (int i = 0; i < gridSize; i++) {
+            for (int j = 0; j < gridSize; j++) {
+                int k = i * gridSize + j;
+                mIndexses[k] = k;
+                mCells[k] = mRgba.submat(i * rows / gridSize, (i + 1) * rows / gridSize, j * cols / gridSize, (j + 1) * cols / gridSize);
+                mCells15[k] = mRgba15.submat(i * rows / gridSize, (i + 1) * rows / gridSize, j * cols / gridSize, (j + 1) * cols / gridSize);
+            }
+        }
+
+        startNewGame();
+    }
+
+    public void startNewGame() {
+        do {
+            shuffle(mIndexses);
+        } while (!isPuzzleSolvable());
+    }
+
+    public void tolggleTileNumbers() {
+        mShowTileNumbers = !mShowTileNumbers;
+    }
+
+    @Override
+    protected Bitmap processFrame(VideoCapture capture) {
+        capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+        int cols = mRgba.cols();
+        int rows = mRgba.rows();
+
+        if (mCells == null)
+            createPuzzle(cols, rows);
+
+        // copy shuffled tiles
+        for (int i = 0; i < gridArea; i++) {
+            int idx = mIndexses[i];
+            if (idx == gridEmptyIdx)
+                mCells15[i].setTo(new Scalar(0x33, 0x33, 0x33, 0xFF));
+            else {
+                mCells[idx].copyTo(mCells15[i]);
+                if (mShowTileNumbers) {
+                    Core.putText(mCells15[i], Integer.toString(1 + idx), new Point((cols / gridSize - mTextWidths[idx]) / 2,
+                            (rows / gridSize + mTextHeights[idx]) / 2), 3/* CV_FONT_HERSHEY_COMPLEX */, 1, new Scalar(255, 0, 0, 255), 2);
+                }
+            }
+        }
+
+        drawGrid(cols, rows);
+
+        Bitmap bmp = Bitmap.createBitmap(cols, rows, Bitmap.Config.ARGB_8888);
+        if (Utils.matToBitmap(mRgba15, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    private void drawGrid(int cols, int rows) {
+        for (int i = 1; i < gridSize; i++) {
+            Core.line(mRgba15, new Point(0, i * rows / gridSize), new Point(cols, i * rows / gridSize), new Scalar(0, 255, 0, 255), 3);
+            Core.line(mRgba15, new Point(i * cols / gridSize, 0), new Point(i * cols / gridSize, rows), new Scalar(0, 255, 0, 255), 3);
+        }
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mCells != null) {
+                for (Mat m : mCells)
+                    m.release();
+            }
+            if (mCells15 != null) {
+                for (Mat m : mCells15)
+                    m.release();
+            }
+            if (mRgba != null)
+                mRgba.release();
+            if (mRgba15 != null)
+                mRgba15.release();
+
+            mRgba = null;
+            mRgba15 = null;
+            mCells = null;
+            mCells15 = null;
+            mIndexses = null;
+        }
+    }
+
+    public boolean onTouch(View v, MotionEvent event) {
+        int cols = mRgba.cols();
+        int rows = mRgba.rows();
+        float xoffset = (getWidth() - cols) / 2;
+        float yoffset = (getHeight() - rows) / 2;
+
+        float x = event.getX() - xoffset;
+        float y = event.getY() - yoffset;
+
+        int row = (int) Math.floor(y * gridSize / rows);
+        int col = (int) Math.floor(x * gridSize / cols);
+
+        if (row < 0 || row >= gridSize || col < 0 || col >= gridSize)
+            return false;
+
+        int idx = row * gridSize + col;
+        int idxtoswap = -1;
+
+        // left
+        if (idxtoswap < 0 && col > 0)
+            if (mIndexses[idx - 1] == gridEmptyIdx)
+                idxtoswap = idx - 1;
+        // right
+        if (idxtoswap < 0 && col < gridSize - 1)
+            if (mIndexses[idx + 1] == gridEmptyIdx)
+                idxtoswap = idx + 1;
+        // top
+        if (idxtoswap < 0 && row > 0)
+            if (mIndexses[idx - gridSize] == gridEmptyIdx)
+                idxtoswap = idx - gridSize;
+        // bottom
+        if (idxtoswap < 0 && row < gridSize - 1)
+            if (mIndexses[idx + gridSize] == gridEmptyIdx)
+                idxtoswap = idx + gridSize;
+
+        // swap
+        if (idxtoswap >= 0) {
+            synchronized (this) {
+                int touched = mIndexses[idx];
+                mIndexses[idx] = mIndexses[idxtoswap];
+                mIndexses[idxtoswap] = touched;
+            }
+        }
+
+        return false;// don't need subsequent touch events
+    }
+}
diff --git a/samples/android/CMakeLists.txt b/samples/android/CMakeLists.txt
new file mode 100644
index 0000000000..28166b7d5e
--- /dev/null
+++ b/samples/android/CMakeLists.txt
@@ -0,0 +1,47 @@
+# ----------------------------------------------------------------------------
+#  CMake file for Android samples. See root CMakeLists.txt
+#
+# ----------------------------------------------------------------------------
+
+if (BUILD_ANDROID_EXAMPLES)
+    project(android_samples)
+
+    include_directories(
+        "${CMAKE_SOURCE_DIR}/modules/core/include"
+        "${CMAKE_SOURCE_DIR}/modules/flann/include"
+        "${CMAKE_SOURCE_DIR}/modules/imgproc/include"
+        "${CMAKE_SOURCE_DIR}/modules/video/include"
+        "${CMAKE_SOURCE_DIR}/modules/highgui/include"
+        "${CMAKE_SOURCE_DIR}/modules/ml/include"
+        "${CMAKE_SOURCE_DIR}/modules/calib3d/include"
+        "${CMAKE_SOURCE_DIR}/modules/features2d/include"
+        "${CMAKE_SOURCE_DIR}/modules/objdetect/include"
+        "${CMAKE_SOURCE_DIR}/modules/legacy/include"
+        "${CMAKE_SOURCE_DIR}/modules/contrib/include"
+    )
+
+    SET (sample_dependencies opencv_contrib opencv_legacy opencv_objdetect opencv_calib3d opencv_features2d opencv_video opencv_highgui opencv_ml opencv_imgproc opencv_flann opencv_core)
+    if(NOT BUILD_SHARED_LIBS)
+        LIST(APPEND sample_dependencies opencv_androidcamera)
+    endif()
+
+    file(GLOB android_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
+    list(REMOVE_ITEM android_samples hello-android)
+    list(SORT android_samples)
+    
+    foreach(sample ${android_samples})
+        if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${sample}/AndroidManifest.xml")
+            add_android_project("${sample}" "${CMAKE_CURRENT_SOURCE_DIR}/${sample}" INSTALL)
+        endif()
+    endforeach()
+
+    #hello-android sample
+    ADD_EXECUTABLE(hello-android hello-android/main.cpp)
+    ADD_DEPENDENCIES(hello-android ${sample_dependencies})
+    TARGET_LINK_LIBRARIES(hello-android ${OPENCV_LINKER_LIBS} ${sample_dependencies})
+    set_target_properties(hello-android PROPERTIES OUTPUT_NAME hello-android RUNTIME_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}")
+    if(INSTALL_ANDROID_EXAMPLES)
+        install(TARGETS hello-android DESTINATION bin COMPONENT main)
+    endif()
+
+endif()
diff --git a/samples/android/face-detection/.classpath b/samples/android/face-detection/.classpath
new file mode 100644
index 0000000000..a0a90f9b1c
--- /dev/null
+++ b/samples/android/face-detection/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/face-detection/.project b/samples/android/face-detection/.project
new file mode 100644
index 0000000000..6ed0ae95ef
--- /dev/null
+++ b/samples/android/face-detection/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Sample - face-detection</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/face-detection/.settings/org.eclipse.jdt.core.prefs b/samples/android/face-detection/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/face-detection/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/face-detection/AndroidManifest.xml b/samples/android/face-detection/AndroidManifest.xml
new file mode 100644
index 0000000000..34ede05629
--- /dev/null
+++ b/samples/android/face-detection/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.fd"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="FdActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/face-detection/default.properties b/samples/android/face-detection/default.properties
new file mode 100644
index 0000000000..74bb01ac06
--- /dev/null
+++ b/samples/android/face-detection/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../OpenCV-2.3.1
+# Project target.
+target=android-8
diff --git a/android/apps/camera_template/res/drawable-hdpi/icon.png b/samples/android/face-detection/res/drawable/icon.png
similarity index 100%
rename from android/apps/camera_template/res/drawable-hdpi/icon.png
rename to samples/android/face-detection/res/drawable/icon.png
diff --git a/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml b/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml
new file mode 100644
index 0000000000..59850cb9c0
--- /dev/null
+++ b/samples/android/face-detection/res/raw/lbpcascade_frontalface.xml
@@ -0,0 +1,1505 @@
+<?xml version="1.0"?>
+<!--
+number of positive samples 3000
+number of negative samples 1500
+-->
+<opencv_storage>
+<cascade type_id="opencv-cascade-classifier">
+  <stageType>BOOST</stageType>
+  <featureType>LBP</featureType>
+  <height>24</height>
+  <width>24</width>
+  <stageParams>
+    <boostType>GAB</boostType>
+    <minHitRate>0.9950000047683716</minHitRate>
+    <maxFalseAlarm>0.5000000000000000</maxFalseAlarm>
+    <weightTrimRate>0.9500000000000000</weightTrimRate>
+    <maxDepth>1</maxDepth>
+    <maxWeakCount>100</maxWeakCount></stageParams>
+  <featureParams>
+    <maxCatCount>256</maxCatCount></featureParams>
+  <stageNum>20</stageNum>
+  <stages>
+    <!-- stage 0 -->
+    <_>
+      <maxWeakCount>3</maxWeakCount>
+      <stageThreshold>-0.7520892024040222</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 46 -67130709 -21569 -1426120013 -1275125205 -21585
+            -16385 587145899 -24005</internalNodes>
+          <leafValues>
+            -0.6543210148811340 0.8888888955116272</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 13 -163512766 -769593758 -10027009 -262145 -514457854
+            -193593353 -524289 -1</internalNodes>
+          <leafValues>
+            -0.7739216089248657 0.7278633713722229</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 2 -363936790 -893203669 -1337948010 -136907894
+            1088782736 -134217726 -741544961 -1590337</internalNodes>
+          <leafValues>
+            -0.7068563103675842 0.6761534214019775</leafValues></_></weakClassifiers></_>
+    <!-- stage 1 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-0.4872078299522400</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 84 2147483647 1946124287 -536870913 2147450879
+            738132490 1061101567 243204619 2147446655</internalNodes>
+          <leafValues>
+            -0.8083735704421997 0.7685696482658386</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 21 2147483647 263176079 1879048191 254749487 1879048191
+            -134252545 -268435457 801111999</internalNodes>
+          <leafValues>
+            -0.7698410153388977 0.6592915654182434</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 106 -98110272 1610939566 -285484400 -850010381
+            -189334372 -1671954433 -571026695 -262145</internalNodes>
+          <leafValues>
+            -0.7506558895111084 0.5444605946540833</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 48 -798690576 -131075 1095771153 -237144073 -65569 -1
+            -216727745 -69206049</internalNodes>
+          <leafValues>
+            -0.7775990366935730 0.5465461611747742</leafValues></_></weakClassifiers></_>
+    <!-- stage 2 -->
+    <_>
+      <maxWeakCount>4</maxWeakCount>
+      <stageThreshold>-1.1592328548431396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 47 -21585 -20549 -100818262 -738254174 -20561 -36865
+            -151016790 -134238549</internalNodes>
+          <leafValues>
+            -0.5601882934570313 0.7743113040924072</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 12 -286003217 183435247 -268994614 -421330945
+            -402686081 1090387966 -286785545 -402653185</internalNodes>
+          <leafValues>
+            -0.6124526262283325 0.6978127956390381</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 26 -50347012 970882927 -50463492 -1253377 -134218251
+            -50364513 -33619992 -172490753</internalNodes>
+          <leafValues>
+            -0.6114496588706970 0.6537628173828125</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 8 -273 -135266321 1877977738 -2088243418 -134217987
+            2146926575 -18910642 1095231247</internalNodes>
+          <leafValues>
+            -0.6854077577590942 0.5403239130973816</leafValues></_></weakClassifiers></_>
+    <!-- stage 3 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.7562355995178223</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 96 -1273 1870659519 -20971602 -67633153 -134250731
+            2004875127 -250 -150995969</internalNodes>
+          <leafValues>
+            -0.4051094949245453 0.7584033608436585</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 33 -868162224 -76810262 -4262145 -257 1465211989
+            -268959873 -2656269 -524289</internalNodes>
+          <leafValues>
+            -0.7388162612915039 0.5340843200683594</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 57 -12817 -49 -541103378 -152950 -38993 -20481 -1153876
+            -72478976</internalNodes>
+          <leafValues>
+            -0.6582943797111511 0.5339496731758118</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 125 -269484161 -452984961 -319816180 -1594032130 -2111
+            -990117891 -488975296 -520947741</internalNodes>
+          <leafValues>
+            -0.5981323719024658 0.5323504805564880</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 53 557787431 670265215 -1342193665 -1075892225
+            1998528318 1056964607 -33570977 -1</internalNodes>
+          <leafValues>
+            -0.6498787999153137 0.4913350641727448</leafValues></_></weakClassifiers></_>
+    <!-- stage 4 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8085358142852783</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 60 -536873708 880195381 -16842788 -20971521 -176687276
+            -168427659 -16777260 -33554626</internalNodes>
+          <leafValues>
+            -0.5278195738792419 0.6946372389793396</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 7 -1 -62981529 -1090591130 805330978 -8388827 -41945787
+            -39577 -531118985</internalNodes>
+          <leafValues>
+            -0.5206505060195923 0.6329920291900635</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 98 -725287348 1347747543 -852489 -16809993 1489881036
+            -167903241 -1 -1</internalNodes>
+          <leafValues>
+            -0.7516061067581177 0.4232024252414703</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 44 -32777 1006582562 -65 935312171 -8388609 -1078198273
+            -1 733886267</internalNodes>
+          <leafValues>
+            -0.7639313936233521 0.4123568832874298</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -85474705 2138828511 -1036436754 817625855
+            1123369029 -58796809 -1013468481 -194513409</internalNodes>
+          <leafValues>
+            -0.5123769044876099 0.5791834592819214</leafValues></_></weakClassifiers></_>
+    <!-- stage 5 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.5549971461296082</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 42 -17409 -20481 -268457797 -134239493 -17473 -1 -21829
+            -21846</internalNodes>
+          <leafValues>
+            -0.3763174116611481 0.7298233509063721</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 6 -805310737 -2098262358 -269504725 682502698
+            2147483519 1740574719 -1090519233 -268472385</internalNodes>
+          <leafValues>
+            -0.5352765917778015 0.5659480094909668</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 61 -67109678 -6145 -8 -87884584 -20481 -1073762305
+            -50856216 -16849696</internalNodes>
+          <leafValues>
+            -0.5678374171257019 0.4961479902267456</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 123 -138428633 1002418167 -1359008245 -1908670465
+            -1346685918 910098423 -1359010520 -1346371657</internalNodes>
+          <leafValues>
+            -0.5706262588500977 0.4572288393974304</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 9 -89138513 -4196353 1256531674 -1330665426 1216308261
+            -36190633 33498198 -151796633</internalNodes>
+          <leafValues>
+            -0.5344601869583130 0.4672054052352905</leafValues></_></weakClassifiers></_>
+    <!-- stage 6 -->
+    <_>
+      <maxWeakCount>5</maxWeakCount>
+      <stageThreshold>-0.8776460289955139</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 105 1073769576 206601725 -34013449 -33554433 -789514004
+            -101384321 -690225153 -264193</internalNodes>
+          <leafValues>
+            -0.7700348496437073 0.5943940877914429</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 30 -1432340997 -823623681 -49153 -34291724 -269484035
+            -1342767105 -1078198273 -1277955</internalNodes>
+          <leafValues>
+            -0.5043668746948242 0.6151274442672730</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 35 -1067385040 -195758209 -436748425 -134217731
+            -50855988 -129 -1 -1</internalNodes>
+          <leafValues>
+            -0.6808040738105774 0.4667325913906097</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 119 832534325 -34111555 -26050561 -423659521 -268468364
+            2105014143 -2114244 -17367185</internalNodes>
+          <leafValues>
+            -0.4927591383457184 0.5401885509490967</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 82 -1089439888 -1080524865 2143059967 -1114121
+            -1140949004 -3 -2361356 -739516</internalNodes>
+          <leafValues>
+            -0.6445107460021973 0.4227822124958038</leafValues></_></weakClassifiers></_>
+    <!-- stage 7 -->
+    <_>
+      <maxWeakCount>6</maxWeakCount>
+      <stageThreshold>-1.1139287948608398</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 52 -1074071553 -1074003969 -1 -1280135430 -5324817 -1
+            -335548482 582134442</internalNodes>
+          <leafValues>
+            -0.5307556986808777 0.6258179545402527</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 99 -706937396 -705364068 -540016724 -570495027
+            -570630659 -587857963 -33628164 -35848193</internalNodes>
+          <leafValues>
+            -0.5227634310722351 0.5049746036529541</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 18 -2035630093 42119158 -268503053 -1671444 261017599
+            1325432815 1954394111 -805306449</internalNodes>
+          <leafValues>
+            -0.4983572661876679 0.5106441378593445</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 111 -282529488 -1558073088 1426018736 -170526448
+            -546832487 -5113037 -34243375 -570427929</internalNodes>
+          <leafValues>
+            -0.4990860521793366 0.5060507059097290</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 92 1016332500 -606301707 915094269 -1080086049
+            -1837027144 -1361600280 2147318747 1067975613</internalNodes>
+          <leafValues>
+            -0.5695009231567383 0.4460467398166657</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 51 -656420166 -15413034 -141599534 -603435836
+            1505950458 -787556946 -79823438 -1326199134</internalNodes>
+          <leafValues>
+            -0.6590405106544495 0.3616424500942230</leafValues></_></weakClassifiers></_>
+    <!-- stage 8 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.8243625760078430</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 28 -901591776 -201916417 -262 -67371009 -143312112
+            -524289 -41943178 -1</internalNodes>
+          <leafValues>
+            -0.4972776770591736 0.6027074456214905</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 112 -4507851 -411340929 -268437513 -67502145 -17350859
+            -32901 -71344315 -29377</internalNodes>
+          <leafValues>
+            -0.4383158981800079 0.5966237187385559</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 69 -75894785 -117379438 -239063587 -12538500 1485072126
+            2076233213 2123118847 801906927</internalNodes>
+          <leafValues>
+            -0.6386105418205261 0.3977999985218048</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 19 -823480413 786628589 -16876049 -1364262914 242165211
+            1315930109 -696268833 -455082829</internalNodes>
+          <leafValues>
+            -0.5512794256210327 0.4282079637050629</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 73 -521411968 6746762 -1396236286 -2038436114
+            -185612509 57669627 -143132877 -1041235973</internalNodes>
+          <leafValues>
+            -0.6418755054473877 0.3549866080284119</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 126 -478153869 1076028979 -1645895615 1365298272
+            -557859073 -339771473 1442574528 -1058802061</internalNodes>
+          <leafValues>
+            -0.4841901361942291 0.4668019413948059</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 45 -246350404 -1650402048 -1610612745 -788400696
+            1467604861 -2787397 1476263935 -4481349</internalNodes>
+          <leafValues>
+            -0.5855734348297119 0.3879135847091675</leafValues></_></weakClassifiers></_>
+    <!-- stage 9 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-1.2237116098403931</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 114 -24819 1572863935 -16809993 -67108865 2146778388
+            1433927541 -268608444 -34865205</internalNodes>
+          <leafValues>
+            -0.2518476545810700 0.7088654041290283</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 97 -1841359 -134271049 -32769 -5767369 -1116675 -2185
+            -8231 -33603327</internalNodes>
+          <leafValues>
+            -0.4303432404994965 0.5283288359642029</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 25 -1359507589 -1360593090 -1073778729 -269553812
+            -809512977 1744707583 -41959433 -134758978</internalNodes>
+          <leafValues>
+            -0.4259553551673889 0.5440809130668640</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 34 729753407 -134270989 -1140907329 -235200777
+            658456383 2147467263 -1140900929 -16385</internalNodes>
+          <leafValues>
+            -0.5605589151382446 0.4220733344554901</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 134 -310380553 -420675595 -193005472 -353568129
+            1205338070 -990380036 887604324 -420544526</internalNodes>
+          <leafValues>
+            -0.5192656517028809 0.4399855434894562</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 16 -1427119361 1978920959 -287119734 -487068946
+            114759245 -540578051 -707510259 -671660453</internalNodes>
+          <leafValues>
+            -0.5013077259063721 0.4570254683494568</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 74 -738463762 -889949281 -328301948 -121832450
+            -1142658284 -1863576559 2146417353 -263185</internalNodes>
+          <leafValues>
+            -0.4631414115428925 0.4790246188640595</leafValues></_></weakClassifiers></_>
+    <!-- stage 10 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.5544230937957764</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 113 -76228780 -65538 -1 -67174401 -148007 -33 -221796
+            -272842924</internalNodes>
+          <leafValues>
+            -0.3949716091156006 0.6082032322883606</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 110 369147696 -1625232112 2138570036 -1189900 790708019
+            -1212613127 799948719 -4456483</internalNodes>
+          <leafValues>
+            -0.4855885505676270 0.4785369932651520</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 37 784215839 -290015241 536832799 -402984963
+            -1342414991 -838864897 -176769 -268456129</internalNodes>
+          <leafValues>
+            -0.4620285332202911 0.4989669024944305</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 41 -486418688 -171915327 -340294900 -21938 -519766032
+            -772751172 -73096060 -585322623</internalNodes>
+          <leafValues>
+            -0.6420643329620361 0.3624351918697357</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 117 -33554953 -475332625 -1423463824 -2077230421
+            -4849669 -2080505925 -219032928 -1071915349</internalNodes>
+          <leafValues>
+            -0.4820112884044647 0.4632140696048737</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 65 -834130468 -134217476 -1349314083 -1073803559
+            -619913764 -1449131844 -1386890321 -1979118423</internalNodes>
+          <leafValues>
+            -0.4465552568435669 0.5061788558959961</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 56 -285249779 1912569855 -16530 -1731022870 -1161904146
+            -1342177297 -268439634 -1464078708</internalNodes>
+          <leafValues>
+            -0.5190586447715759 0.4441480338573456</leafValues></_></weakClassifiers></_>
+    <!-- stage 11 -->
+    <_>
+      <maxWeakCount>7</maxWeakCount>
+      <stageThreshold>-0.7161560654640198</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 20 1246232575 1078001186 -10027057 60102 -277348353
+            -43646987 -1210581153 1195769615</internalNodes>
+          <leafValues>
+            -0.4323809444904327 0.5663768053054810</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 15 -778583572 -612921106 -578775890 -4036478
+            -1946580497 -1164766570 -1986687009 -12103599</internalNodes>
+          <leafValues>
+            -0.4588732719421387 0.4547033011913300</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 129 -1073759445 2013231743 -1363169553 -1082459201
+            -1414286549 868185983 -1356133589 -1077936257</internalNodes>
+          <leafValues>
+            -0.5218553543090820 0.4111092388629913</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 102 -84148365 -2093417722 -1204850272 564290299
+            -67121221 -1342177350 -1309195902 -776734797</internalNodes>
+          <leafValues>
+            -0.4920000731945038 0.4326725304126740</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 88 -25694458 67104495 -290216278 -168563037 2083877442
+            1702788383 -144191964 -234882162</internalNodes>
+          <leafValues>
+            -0.4494568109512329 0.4448510706424713</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 59 -857980836 904682741 -1612267521 232279415
+            1550862252 -574825221 -357380888 -4579409</internalNodes>
+          <leafValues>
+            -0.5180826783180237 0.3888972699642181</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 27 -98549440 -137838400 494928389 -246013630 939541351
+            -1196072350 -620603549 2137216273</internalNodes>
+          <leafValues>
+            -0.6081240773200989 0.3333222270011902</leafValues></_></weakClassifiers></_>
+    <!-- stage 12 -->
+    <_>
+      <maxWeakCount>8</maxWeakCount>
+      <stageThreshold>-0.6743940711021423</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 29 -150995201 2071191945 -1302151626 536934335
+            -1059008937 914128709 1147328110 -268369925</internalNodes>
+          <leafValues>
+            -0.1790193915367127 0.6605972051620483</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 128 -134509479 1610575703 -1342177289 1861484541
+            -1107833788 1577058173 -333558568 -136319041</internalNodes>
+          <leafValues>
+            -0.3681024610996246 0.5139749646186829</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 70 -1 1060154476 -1090984524 -630918524 -539492875
+            779616255 -839568424 -321</internalNodes>
+          <leafValues>
+            -0.3217232525348663 0.6171553134918213</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 4 -269562385 -285029906 -791084350 -17923776 235286671
+            1275504943 1344390399 -966276889</internalNodes>
+          <leafValues>
+            -0.4373284578323364 0.4358185231685638</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 76 17825984 -747628419 595427229 1474759671 575672208
+            -1684005538 872217086 -1155858277</internalNodes>
+          <leafValues>
+            -0.4404836893081665 0.4601220190525055</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 124 -336593039 1873735591 -822231622 -355795238
+            -470820869 -1997537409 -1057132384 -1015285005</internalNodes>
+          <leafValues>
+            -0.4294152259826660 0.4452161788940430</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 54 -834212130 -593694721 -322142257 -364892500
+            -951029539 -302125121 -1615106053 -79249765</internalNodes>
+          <leafValues>
+            -0.3973052501678467 0.4854526817798615</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 95 1342144479 2147431935 -33554561 -47873 -855685912 -1
+            1988052447 536827383</internalNodes>
+          <leafValues>
+            -0.7054683566093445 0.2697997391223908</leafValues></_></weakClassifiers></_>
+    <!-- stage 13 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.2042298316955566</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 39 1431368960 -183437936 -537002499 -137497097
+            1560590321 -84611081 -2097193 -513</internalNodes>
+          <leafValues>
+            -0.5905947685241699 0.5101932883262634</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 120 -1645259691 2105491231 2130706431 1458995007
+            -8567536 -42483883 -33780003 -21004417</internalNodes>
+          <leafValues>
+            -0.4449204802513123 0.4490709304809570</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 89 -612381022 -505806938 -362027516 -452985106
+            275854917 1920431639 -12600561 -134221825</internalNodes>
+          <leafValues>
+            -0.4693818688392639 0.4061094820499420</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 14 -805573153 -161 -554172679 -530519488 -16779441
+            2000682871 -33604275 -150997129</internalNodes>
+          <leafValues>
+            -0.3600351214408875 0.5056326985359192</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 67 6192 435166195 1467449341 2046691505 -1608493775
+            -4755729 -1083162625 -71365637</internalNodes>
+          <leafValues>
+            -0.4459891915321350 0.4132415652275085</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 86 -41689215 -3281034 1853357967 -420712635 -415924289
+            -270209208 -1088293113 -825311232</internalNodes>
+          <leafValues>
+            -0.4466069042682648 0.4135067760944367</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 80 -117391116 -42203396 2080374461 -188709 -542008165
+            -356831940 -1091125345 -1073796897</internalNodes>
+          <leafValues>
+            -0.3394956290721893 0.5658645033836365</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 75 -276830049 1378714472 -1342181951 757272098
+            1073740607 -282199241 -415761549 170896931</internalNodes>
+          <leafValues>
+            -0.5346512198448181 0.3584479391574860</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 55 -796075825 -123166849 2113667055 -217530421
+            -1107432194 -16385 -806359809 -391188771</internalNodes>
+          <leafValues>
+            -0.4379335641860962 0.4123645126819611</leafValues></_></weakClassifiers></_>
+    <!-- stage 14 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.8402050137519836</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 71 -890246622 15525883 -487690486 47116238 -1212319899
+            -1291847681 -68159890 -469829921</internalNodes>
+          <leafValues>
+            -0.2670986354351044 0.6014143228530884</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 31 -1361180685 -1898008841 -1090588811 -285410071
+            -1074016265 -840443905 2147221487 -262145</internalNodes>
+          <leafValues>
+            -0.4149844348430634 0.4670888185501099</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 40 1426190596 1899364271 2142731795 -142607505
+            -508232452 -21563393 -41960001 -65</internalNodes>
+          <leafValues>
+            -0.4985891580581665 0.3719584941864014</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 109 -201337965 10543906 -236498096 -746195597
+            1974565825 -15204415 921907633 -190058309</internalNodes>
+          <leafValues>
+            -0.4568729996681213 0.3965812027454376</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 130 -595026732 -656401928 -268649235 -571490699
+            -440600392 -133131 -358810952 -2004088646</internalNodes>
+          <leafValues>
+            -0.4770836830139160 0.3862601518630981</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 66 941674740 -1107882114 1332789109 -67691015
+            -1360463693 -1556612430 -609108546 733546933</internalNodes>
+          <leafValues>
+            -0.4877715110778809 0.3778986334800720</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 49 -17114945 -240061474 1552871558 -82775604 -932393844
+            -1308544889 -532635478 -99042357</internalNodes>
+          <leafValues>
+            -0.3721654713153839 0.4994400143623352</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 133 -655906006 1405502603 -939205164 1884929228
+            -498859222 559417357 -1928559445 -286264385</internalNodes>
+          <leafValues>
+            -0.3934195041656494 0.4769641458988190</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 0 -335837777 1860677295 -90 -1946186226 931096183
+            251612987 2013265917 -671232197</internalNodes>
+          <leafValues>
+            -0.4323300719261169 0.4342164099216461</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 103 37769424 -137772680 374692301 2002666345 -536176194
+            -1644484728 807009019 1069089930</internalNodes>
+          <leafValues>
+            -0.4993278682231903 0.3665378093719482</leafValues></_></weakClassifiers></_>
+    <!-- stage 15 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-1.1974394321441650</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 43 -5505 2147462911 2143265466 -4511070 -16450 -257
+            -201348440 -71333206</internalNodes>
+          <leafValues>
+            -0.3310225307941437 0.5624626278877258</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 90 -136842268 -499330741 2015250980 -87107126
+            -641665744 -788524639 -1147864792 -134892563</internalNodes>
+          <leafValues>
+            -0.5266560912132263 0.3704403042793274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 104 -146800880 -1780368555 2111170033 -140904684
+            -16777551 -1946681885 -1646463595 -839131947</internalNodes>
+          <leafValues>
+            -0.4171888828277588 0.4540435671806335</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 85 -832054034 -981663763 -301990281 -578814081
+            -932319000 -1997406723 -33555201 -69206017</internalNodes>
+          <leafValues>
+            -0.4556705355644226 0.3704262077808380</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 24 -118492417 -1209026825 1119023838 -1334313353
+            1112948738 -297319313 1378887291 -139469193</internalNodes>
+          <leafValues>
+            -0.4182529747486115 0.4267231225967407</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 78 -1714382628 -2353704 -112094959 -549613092
+            -1567058760 -1718550464 -342315012 -1074972227</internalNodes>
+          <leafValues>
+            -0.3625369668006897 0.4684656262397766</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 5 -85219702 316836394 -33279 1904970288 2117267315
+            -260901769 -621461759 -88607770</internalNodes>
+          <leafValues>
+            -0.4742925167083740 0.3689507246017456</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 11 -294654041 -353603585 -1641159686 -50331921
+            -2080899877 1145569279 -143132713 -152044037</internalNodes>
+          <leafValues>
+            -0.3666271567344666 0.4580127298831940</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 32 1887453658 -638545712 -1877976819 -34320972
+            -1071067983 -661345416 -583338277 1060190561</internalNodes>
+          <leafValues>
+            -0.4567637443542481 0.3894708156585693</leafValues></_></weakClassifiers></_>
+    <!-- stage 16 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.5733128190040588</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 122 -994063296 1088745462 -318837116 -319881377
+            1102566613 1165490103 -121679694 -134744129</internalNodes>
+          <leafValues>
+            -0.4055117964744568 0.5487945079803467</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 68 -285233233 -538992907 1811935199 -369234005 -529
+            -20593 -20505 -1561401854</internalNodes>
+          <leafValues>
+            -0.3787897229194641 0.4532003402709961</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 58 -1335245632 1968917183 1940861695 536816369
+            -1226071367 -570908176 457026619 1000020667</internalNodes>
+          <leafValues>
+            -0.4258328974246979 0.4202791750431061</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 94 -1360318719 -1979797897 -50435249 -18646473
+            -608879292 -805306691 -269304244 -17840167</internalNodes>
+          <leafValues>
+            -0.4561023116111755 0.4002747833728790</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 87 2062765935 -16449 -1275080721 -16406 45764335
+            -1090552065 -772846337 -570464322</internalNodes>
+          <leafValues>
+            -0.4314672648906708 0.4086346626281738</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 127 -536896021 1080817663 -738234288 -965478709
+            -2082767969 1290855887 1993822934 -990381609</internalNodes>
+          <leafValues>
+            -0.4174543321132660 0.4249868988990784</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 3 -818943025 168730891 -293610428 -79249354 669224671
+            621166734 1086506807 1473768907</internalNodes>
+          <leafValues>
+            -0.4321364760398865 0.4090838730335236</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 79 -68895696 -67107736 -1414315879 -841676168
+            -619843344 -1180610531 -1081990469 1043203389</internalNodes>
+          <leafValues>
+            -0.5018386244773865 0.3702533841133118</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 116 -54002134 -543485719 -2124882422 -1437445858
+            -115617074 -1195787391 -1096024366 -2140472445</internalNodes>
+          <leafValues>
+            -0.5037505626678467 0.3564981222152710</leafValues></_></weakClassifiers></_>
+    <!-- stage 17 -->
+    <_>
+      <maxWeakCount>9</maxWeakCount>
+      <stageThreshold>-0.4892596900463104</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 132 -67113211 2003808111 1862135111 846461923 -2752
+            2002237273 -273154752 1937223539</internalNodes>
+          <leafValues>
+            -0.2448196411132813 0.5689709186553955</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 62 1179423888 -78064940 -611839555 -539167899
+            -1289358360 -1650810108 -892540499 -1432827684</internalNodes>
+          <leafValues>
+            -0.4633283913135529 0.3587929606437683</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 23 -285212705 -78450761 -656212031 -264050110 -27787425
+            -1334349961 -547662981 -135796924</internalNodes>
+          <leafValues>
+            -0.3731099069118500 0.4290455579757690</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 77 341863476 403702016 -550588417 1600194541
+            -1080690735 951127993 -1388580949 -1153717473</internalNodes>
+          <leafValues>
+            -0.3658909499645233 0.4556473195552826</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 22 -586880702 -204831512 -100644596 -39319550
+            -1191150794 705692513 457203315 -75806957</internalNodes>
+          <leafValues>
+            -0.5214384198188782 0.3221037387847900</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 72 -416546870 545911370 -673716192 -775559454
+            -264113598 139424 -183369982 -204474641</internalNodes>
+          <leafValues>
+            -0.4289036989212036 0.4004956185817719</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 50 -1026505020 -589692154 -1740499937 -1563770497
+            1348491006 -60710713 -1109853489 -633909413</internalNodes>
+          <leafValues>
+            -0.4621542394161224 0.3832748532295227</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 108 -1448872304 -477895040 -1778390608 -772418127
+            -1789923416 -1612057181 -805306693 -1415842113</internalNodes>
+          <leafValues>
+            -0.3711548447608948 0.4612701535224915</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 92 407905424 -582449988 52654751 -1294472 -285103725
+            -74633006 1871559083 1057955850</internalNodes>
+          <leafValues>
+            -0.5180652141571045 0.3205870389938355</leafValues></_></weakClassifiers></_>
+    <!-- stage 18 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.5911940932273865</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 81 4112 -1259563825 -846671428 -100902460 1838164148
+            -74153752 -90653988 -1074263896</internalNodes>
+          <leafValues>
+            -0.2592592537403107 0.5873016119003296</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 1 -285216785 -823206977 -1085589 -1081346 1207959293
+            1157103471 2097133565 -2097169</internalNodes>
+          <leafValues>
+            -0.3801195919513702 0.4718827307224274</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 121 -12465 -536875169 2147478367 2130706303 -37765492
+            -866124467 -318782328 -1392509185</internalNodes>
+          <leafValues>
+            -0.3509117066860199 0.5094807147979736</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 38 2147449663 -20741 -16794757 1945873146 -16710 -1
+            -8406341 -67663041</internalNodes>
+          <leafValues>
+            -0.4068757295608521 0.4130136370658875</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 17 -155191713 866117231 1651407483 548272812 -479201468
+            -447742449 1354229504 -261884429</internalNodes>
+          <leafValues>
+            -0.4557141065597534 0.3539792001247406</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 100 -225319378 -251682065 -492783986 -792341777
+            -1287261695 1393643841 -11274182 -213909521</internalNodes>
+          <leafValues>
+            -0.4117803275585175 0.4118592441082001</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 63 -382220122 -2002072729 -51404800 -371201558
+            -923011069 -2135301457 -2066104743 -1042557441</internalNodes>
+          <leafValues>
+            -0.4008397758007050 0.4034757018089294</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 101 -627353764 -48295149 1581203952 -436258614
+            -105268268 -1435893445 -638126888 -1061107126</internalNodes>
+          <leafValues>
+            -0.5694189667701721 0.2964762747287750</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 118 -8399181 1058107691 -621022752 -251003468 -12582915
+            -574619739 -994397789 -1648362021</internalNodes>
+          <leafValues>
+            -0.3195341229438782 0.5294018983840942</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 92 -348343812 -1078389516 1717960437 364735981
+            -1783841602 -4883137 -457572354 -1076950384</internalNodes>
+          <leafValues>
+            -0.3365339040756226 0.5067458748817444</leafValues></_></weakClassifiers></_>
+    <!-- stage 19 -->
+    <_>
+      <maxWeakCount>10</maxWeakCount>
+      <stageThreshold>-0.7612916231155396</stageThreshold>
+      <weakClassifiers>
+        <!-- tree 0 -->
+        <_>
+          <internalNodes>
+            0 -1 10 -1976661318 -287957604 -1659497122 -782068 43591089
+            -453637880 1435470000 -1077438561</internalNodes>
+          <leafValues>
+            -0.4204545319080353 0.5165745615959168</leafValues></_>
+        <!-- tree 1 -->
+        <_>
+          <internalNodes>
+            0 -1 131 -67110925 14874979 -142633168 -1338923040
+            2046713291 -2067933195 1473503712 -789579837</internalNodes>
+          <leafValues>
+            -0.3762553930282593 0.4075302779674530</leafValues></_>
+        <!-- tree 2 -->
+        <_>
+          <internalNodes>
+            0 -1 83 -272814301 -1577073 -1118685 -305156120 -1052289
+            -1073813756 -538971154 -355523038</internalNodes>
+          <leafValues>
+            -0.4253497421741486 0.3728055357933044</leafValues></_>
+        <!-- tree 3 -->
+        <_>
+          <internalNodes>
+            0 -1 135 -2233 -214486242 -538514758 573747007 -159390971
+            1994225489 -973738098 -203424005</internalNodes>
+          <leafValues>
+            -0.3601998090744019 0.4563256204128265</leafValues></_>
+        <!-- tree 4 -->
+        <_>
+          <internalNodes>
+            0 -1 115 -261031688 -1330369299 -641860609 1029570301
+            -1306461192 -1196149518 -1529767778 683139823</internalNodes>
+          <leafValues>
+            -0.4034293889999390 0.4160816967487335</leafValues></_>
+        <!-- tree 5 -->
+        <_>
+          <internalNodes>
+            0 -1 64 -572993608 -34042628 -417865 -111109 -1433365268
+            -19869715 -1920939864 -1279457063</internalNodes>
+          <leafValues>
+            -0.3620899617671967 0.4594142735004425</leafValues></_>
+        <!-- tree 6 -->
+        <_>
+          <internalNodes>
+            0 -1 36 -626275097 -615256993 1651946018 805366393
+            2016559730 -430780849 -799868165 -16580645</internalNodes>
+          <leafValues>
+            -0.3903816640377045 0.4381459355354309</leafValues></_>
+        <!-- tree 7 -->
+        <_>
+          <internalNodes>
+            0 -1 93 1354797300 -1090957603 1976418270 -1342502178
+            -1851873892 -1194637077 -1153521668 -1108399474</internalNodes>
+          <leafValues>
+            -0.3591445386409760 0.4624078869819641</leafValues></_>
+        <!-- tree 8 -->
+        <_>
+          <internalNodes>
+            0 -1 91 68157712 1211368313 -304759523 1063017136 798797750
+            -275513546 648167355 -1145357350</internalNodes>
+          <leafValues>
+            -0.4297670423984528 0.4023293554782867</leafValues></_>
+        <!-- tree 9 -->
+        <_>
+          <internalNodes>
+            0 -1 107 -546318240 -1628569602 -163577944 -537002306
+            -545456389 -1325465645 -380446736 -1058473386</internalNodes>
+          <leafValues>
+            -0.5727006793022156 0.2995934784412384</leafValues></_></weakClassifiers></_></stages>
+  <features>
+    <_>
+      <rect>
+        0 0 3 5</rect></_>
+    <_>
+      <rect>
+        0 0 4 2</rect></_>
+    <_>
+      <rect>
+        0 0 6 3</rect></_>
+    <_>
+      <rect>
+        0 1 2 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 3</rect></_>
+    <_>
+      <rect>
+        0 1 3 7</rect></_>
+    <_>
+      <rect>
+        0 4 3 3</rect></_>
+    <_>
+      <rect>
+        0 11 3 4</rect></_>
+    <_>
+      <rect>
+        0 12 8 4</rect></_>
+    <_>
+      <rect>
+        0 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 0 5 3</rect></_>
+    <_>
+      <rect>
+        1 1 2 2</rect></_>
+    <_>
+      <rect>
+        1 3 3 1</rect></_>
+    <_>
+      <rect>
+        1 7 4 4</rect></_>
+    <_>
+      <rect>
+        1 12 2 2</rect></_>
+    <_>
+      <rect>
+        1 13 4 1</rect></_>
+    <_>
+      <rect>
+        1 14 4 3</rect></_>
+    <_>
+      <rect>
+        1 17 3 2</rect></_>
+    <_>
+      <rect>
+        2 0 2 3</rect></_>
+    <_>
+      <rect>
+        2 1 2 2</rect></_>
+    <_>
+      <rect>
+        2 2 4 6</rect></_>
+    <_>
+      <rect>
+        2 3 4 4</rect></_>
+    <_>
+      <rect>
+        2 7 2 1</rect></_>
+    <_>
+      <rect>
+        2 11 2 3</rect></_>
+    <_>
+      <rect>
+        2 17 3 2</rect></_>
+    <_>
+      <rect>
+        3 0 2 2</rect></_>
+    <_>
+      <rect>
+        3 1 7 3</rect></_>
+    <_>
+      <rect>
+        3 7 2 1</rect></_>
+    <_>
+      <rect>
+        3 7 2 4</rect></_>
+    <_>
+      <rect>
+        3 18 2 2</rect></_>
+    <_>
+      <rect>
+        4 0 2 3</rect></_>
+    <_>
+      <rect>
+        4 3 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 1</rect></_>
+    <_>
+      <rect>
+        4 6 2 5</rect></_>
+    <_>
+      <rect>
+        4 7 5 2</rect></_>
+    <_>
+      <rect>
+        4 8 4 3</rect></_>
+    <_>
+      <rect>
+        4 18 2 2</rect></_>
+    <_>
+      <rect>
+        5 0 2 2</rect></_>
+    <_>
+      <rect>
+        5 3 4 4</rect></_>
+    <_>
+      <rect>
+        5 6 2 5</rect></_>
+    <_>
+      <rect>
+        5 9 2 2</rect></_>
+    <_>
+      <rect>
+        5 10 2 2</rect></_>
+    <_>
+      <rect>
+        6 3 4 4</rect></_>
+    <_>
+      <rect>
+        6 4 4 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 3</rect></_>
+    <_>
+      <rect>
+        6 5 2 5</rect></_>
+    <_>
+      <rect>
+        6 5 4 3</rect></_>
+    <_>
+      <rect>
+        6 6 4 2</rect></_>
+    <_>
+      <rect>
+        6 6 4 4</rect></_>
+    <_>
+      <rect>
+        6 18 1 2</rect></_>
+    <_>
+      <rect>
+        6 21 2 1</rect></_>
+    <_>
+      <rect>
+        7 0 3 7</rect></_>
+    <_>
+      <rect>
+        7 4 2 3</rect></_>
+    <_>
+      <rect>
+        7 9 5 1</rect></_>
+    <_>
+      <rect>
+        7 21 2 1</rect></_>
+    <_>
+      <rect>
+        8 0 1 4</rect></_>
+    <_>
+      <rect>
+        8 5 2 2</rect></_>
+    <_>
+      <rect>
+        8 5 3 2</rect></_>
+    <_>
+      <rect>
+        8 17 3 1</rect></_>
+    <_>
+      <rect>
+        8 18 1 2</rect></_>
+    <_>
+      <rect>
+        9 0 5 3</rect></_>
+    <_>
+      <rect>
+        9 2 2 6</rect></_>
+    <_>
+      <rect>
+        9 5 1 1</rect></_>
+    <_>
+      <rect>
+        9 11 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 1 1</rect></_>
+    <_>
+      <rect>
+        9 16 2 1</rect></_>
+    <_>
+      <rect>
+        9 17 1 1</rect></_>
+    <_>
+      <rect>
+        9 18 1 1</rect></_>
+    <_>
+      <rect>
+        10 5 1 2</rect></_>
+    <_>
+      <rect>
+        10 5 3 3</rect></_>
+    <_>
+      <rect>
+        10 7 1 5</rect></_>
+    <_>
+      <rect>
+        10 8 1 1</rect></_>
+    <_>
+      <rect>
+        10 9 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 1</rect></_>
+    <_>
+      <rect>
+        10 10 1 2</rect></_>
+    <_>
+      <rect>
+        10 14 3 3</rect></_>
+    <_>
+      <rect>
+        10 15 1 1</rect></_>
+    <_>
+      <rect>
+        10 15 2 1</rect></_>
+    <_>
+      <rect>
+        10 16 1 1</rect></_>
+    <_>
+      <rect>
+        10 16 2 1</rect></_>
+    <_>
+      <rect>
+        10 17 1 1</rect></_>
+    <_>
+      <rect>
+        10 21 1 1</rect></_>
+    <_>
+      <rect>
+        11 3 2 2</rect></_>
+    <_>
+      <rect>
+        11 5 1 2</rect></_>
+    <_>
+      <rect>
+        11 5 3 3</rect></_>
+    <_>
+      <rect>
+        11 5 4 6</rect></_>
+    <_>
+      <rect>
+        11 6 1 1</rect></_>
+    <_>
+      <rect>
+        11 7 2 2</rect></_>
+    <_>
+      <rect>
+        11 8 1 2</rect></_>
+    <_>
+      <rect>
+        11 10 1 1</rect></_>
+    <_>
+      <rect>
+        11 10 1 2</rect></_>
+    <_>
+      <rect>
+        11 15 1 1</rect></_>
+    <_>
+      <rect>
+        11 17 1 1</rect></_>
+    <_>
+      <rect>
+        11 18 1 1</rect></_>
+    <_>
+      <rect>
+        12 0 2 2</rect></_>
+    <_>
+      <rect>
+        12 1 2 5</rect></_>
+    <_>
+      <rect>
+        12 2 4 1</rect></_>
+    <_>
+      <rect>
+        12 3 1 3</rect></_>
+    <_>
+      <rect>
+        12 7 3 4</rect></_>
+    <_>
+      <rect>
+        12 10 3 2</rect></_>
+    <_>
+      <rect>
+        12 11 1 1</rect></_>
+    <_>
+      <rect>
+        12 12 3 2</rect></_>
+    <_>
+      <rect>
+        12 14 4 3</rect></_>
+    <_>
+      <rect>
+        12 17 1 1</rect></_>
+    <_>
+      <rect>
+        12 21 2 1</rect></_>
+    <_>
+      <rect>
+        13 6 2 5</rect></_>
+    <_>
+      <rect>
+        13 7 3 5</rect></_>
+    <_>
+      <rect>
+        13 11 3 2</rect></_>
+    <_>
+      <rect>
+        13 17 2 2</rect></_>
+    <_>
+      <rect>
+        13 17 3 2</rect></_>
+    <_>
+      <rect>
+        13 18 1 2</rect></_>
+    <_>
+      <rect>
+        13 18 2 2</rect></_>
+    <_>
+      <rect>
+        14 0 2 2</rect></_>
+    <_>
+      <rect>
+        14 1 1 3</rect></_>
+    <_>
+      <rect>
+        14 2 3 2</rect></_>
+    <_>
+      <rect>
+        14 7 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 2 1</rect></_>
+    <_>
+      <rect>
+        14 13 3 3</rect></_>
+    <_>
+      <rect>
+        14 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 2</rect></_>
+    <_>
+      <rect>
+        15 0 2 3</rect></_>
+    <_>
+      <rect>
+        15 4 3 2</rect></_>
+    <_>
+      <rect>
+        15 4 3 6</rect></_>
+    <_>
+      <rect>
+        15 6 3 2</rect></_>
+    <_>
+      <rect>
+        15 11 3 4</rect></_>
+    <_>
+      <rect>
+        15 13 3 2</rect></_>
+    <_>
+      <rect>
+        15 17 2 2</rect></_>
+    <_>
+      <rect>
+        15 17 3 2</rect></_>
+    <_>
+      <rect>
+        16 1 2 3</rect></_>
+    <_>
+      <rect>
+        16 3 2 4</rect></_>
+    <_>
+      <rect>
+        16 6 1 1</rect></_>
+    <_>
+      <rect>
+        16 16 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 2</rect></_>
+    <_>
+      <rect>
+        17 1 2 5</rect></_>
+    <_>
+      <rect>
+        17 12 2 2</rect></_>
+    <_>
+      <rect>
+        18 0 2 2</rect></_></features></cascade>
+</opencv_storage>
diff --git a/samples/android/face-detection/res/values/strings.xml b/samples/android/face-detection/res/values/strings.xml
new file mode 100644
index 0000000000..cc59467ff5
--- /dev/null
+++ b/samples/android/face-detection/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Sample - face-detection</string>
+</resources>
diff --git a/samples/android/face-detection/src/org/opencv/samples/fd/FdActivity.java b/samples/android/face-detection/src/org/opencv/samples/fd/FdActivity.java
new file mode 100644
index 0000000000..05e9efd27b
--- /dev/null
+++ b/samples/android/face-detection/src/org/opencv/samples/fd/FdActivity.java
@@ -0,0 +1,56 @@
+package org.opencv.samples.fd;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class FdActivity extends Activity {
+    private static final String TAG         = "Sample::Activity";
+
+    private MenuItem            mItemFace50;
+    private MenuItem            mItemFace40;
+    private MenuItem            mItemFace30;
+    private MenuItem            mItemFace20;
+
+    public static float         minFaceSize = 0.5f;
+
+    public FdActivity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new FdView(this));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemFace50 = menu.add("Face size 50%");
+        mItemFace40 = menu.add("Face size 40%");
+        mItemFace30 = menu.add("Face size 30%");
+        mItemFace20 = menu.add("Face size 20%");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemFace50)
+            minFaceSize = 0.5f;
+        else if (item == mItemFace40)
+            minFaceSize = 0.4f;
+        else if (item == mItemFace30)
+            minFaceSize = 0.3f;
+        else if (item == mItemFace20)
+            minFaceSize = 0.2f;
+        return true;
+    }
+}
diff --git a/samples/android/face-detection/src/org/opencv/samples/fd/FdView.java b/samples/android/face-detection/src/org/opencv/samples/fd/FdView.java
new file mode 100644
index 0000000000..538bbdb847
--- /dev/null
+++ b/samples/android/face-detection/src/org/opencv/samples/fd/FdView.java
@@ -0,0 +1,116 @@
+package org.opencv.samples.fd;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Rect;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+import org.opencv.objdetect.CascadeClassifier;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+import android.view.SurfaceHolder;
+
+class FdView extends SampleCvViewBase {
+    private static final String TAG = "Sample::FdView";
+    private Mat                 mRgba;
+    private Mat                 mGray;
+
+    private CascadeClassifier   mCascade;
+
+    public FdView(Context context) {
+        super(context);
+
+        try {
+            InputStream is = context.getResources().openRawResource(R.raw.lbpcascade_frontalface);
+            File cascadeDir = context.getDir("cascade", Context.MODE_PRIVATE);
+            File cascadeFile = new File(cascadeDir, "lbpcascade_frontalface.xml");
+            FileOutputStream os = new FileOutputStream(cascadeFile);
+
+            byte[] buffer = new byte[4096];
+            int bytesRead;
+            while ((bytesRead = is.read(buffer)) != -1) {
+                os.write(buffer, 0, bytesRead);
+            }
+            is.close();
+            os.close();
+
+            mCascade = new CascadeClassifier(cascadeFile.getAbsolutePath());
+            if (mCascade.empty()) {
+                Log.e(TAG, "Failed to load cascade classifier");
+                mCascade = null;
+            } else
+                Log.i(TAG, "Loaded cascade classifier from " + cascadeFile.getAbsolutePath());
+
+            cascadeFile.delete();
+            cascadeDir.delete();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+            Log.e(TAG, "Failed to load cascade. Exception thrown: " + e);
+        }
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+
+        synchronized (this) {
+            // initialize Mats before usage
+            mGray = new Mat();
+            mRgba = new Mat();
+        }
+    }
+
+    @Override
+    protected Bitmap processFrame(VideoCapture capture) {
+        capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+        capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+
+        if (mCascade != null) {
+            int height = mGray.rows();
+            int faceSize = Math.round(height * FdActivity.minFaceSize);
+            List<Rect> faces = new LinkedList<Rect>();
+            mCascade.detectMultiScale(mGray, faces, 1.1, 2, 2 // TODO: objdetect.CV_HAAR_SCALE_IMAGE
+                    , new Size(faceSize, faceSize));
+
+            for (Rect r : faces)
+                Core.rectangle(mRgba, r.tl(), r.br(), new Scalar(0, 255, 0, 255), 3);
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
+
+        if (Utils.matToBitmap(mRgba, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mRgba != null)
+                mRgba.release();
+            if (mGray != null)
+                mGray.release();
+
+            mRgba = null;
+            mGray = null;
+        }
+    }
+}
diff --git a/samples/android/face-detection/src/org/opencv/samples/fd/FpsMeter.java b/samples/android/face-detection/src/org/opencv/samples/fd/FpsMeter.java
new file mode 100644
index 0000000000..5e96574d02
--- /dev/null
+++ b/samples/android/face-detection/src/org/opencv/samples/fd/FpsMeter.java
@@ -0,0 +1,50 @@
+package org.opencv.samples.fd;
+
+import java.text.DecimalFormat;
+
+import org.opencv.core.Core;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.util.Log;
+
+public class FpsMeter {
+    private static final String TAG       = "Sample::FpsMeter";
+    int                         step;
+    int                         framesCouner;
+    double                      freq;
+    long                        prevFrameTime;
+    String                      strfps;
+    DecimalFormat               twoPlaces = new DecimalFormat("0.00");
+    Paint                       paint;
+
+    public void init() {
+        step = 20;
+        framesCouner = 0;
+        freq = Core.getTickFrequency();
+        prevFrameTime = Core.getTickCount();
+        strfps = "";
+
+        paint = new Paint();
+        paint.setColor(Color.BLUE);
+        paint.setTextSize(50);
+    }
+
+    public void measure() {
+        framesCouner++;
+        if (framesCouner % step == 0) {
+            long time = Core.getTickCount();
+            double fps = step * freq / (time - prevFrameTime);
+            prevFrameTime = time;
+            DecimalFormat twoPlaces = new DecimalFormat("0.00");
+            strfps = twoPlaces.format(fps) + " FPS";
+            Log.i(TAG, strfps);
+        }
+    }
+
+    public void draw(Canvas canvas, float offsetx, float offsety) {
+        canvas.drawText(strfps, 20 + offsetx, 10 + 50 + offsety, paint);
+    }
+
+}
diff --git a/samples/android/face-detection/src/org/opencv/samples/fd/SampleCvViewBase.java b/samples/android/face-detection/src/org/opencv/samples/fd/SampleCvViewBase.java
new file mode 100644
index 0000000000..a27464704e
--- /dev/null
+++ b/samples/android/face-detection/src/org/opencv/samples/fd/SampleCvViewBase.java
@@ -0,0 +1,117 @@
+package org.opencv.samples.fd;
+
+import java.util.List;
+
+import org.opencv.core.Size;
+import org.opencv.highgui.VideoCapture;
+import org.opencv.highgui.Highgui;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private SurfaceHolder       mHolder;
+    private VideoCapture        mCamera;
+    private FpsMeter            mFps;
+
+    public SampleCvViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        mFps = new FpsMeter();
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        synchronized (this) {
+            if (mCamera != null && mCamera.isOpened()) {
+                Log.i(TAG, "before mCamera.getSupportedPreviewSizes()");
+                List<Size> sizes = mCamera.getSupportedPreviewSizes();
+                Log.i(TAG, "after mCamera.getSupportedPreviewSizes()");
+                int mFrameWidth = width;
+                int mFrameHeight = height;
+
+                // selecting optimal camera preview size
+                {
+                    double minDiff = Double.MAX_VALUE;
+                    for (Size size : sizes) {
+                        if (Math.abs(size.height - height) < minDiff) {
+                            mFrameWidth = (int) size.width;
+                            mFrameHeight = (int) size.height;
+                            minDiff = Math.abs(size.height - height);
+                        }
+                    }
+                }
+
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
+            }
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+        if (mCamera.isOpened()) {
+            (new Thread(this)).start();
+        } else {
+            mCamera.release();
+            mCamera = null;
+            Log.e(TAG, "Failed to open native camera");
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(VideoCapture capture);
+
+    public void run() {
+        Log.i(TAG, "Starting processing thread");
+        mFps.init();
+
+        while (true) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                if (mCamera == null)
+                    break;
+
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "mCamera.grab() failed");
+                    break;
+                }
+
+                bmp = processFrame(mCamera);
+
+                mFps.measure();
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
+                    mFps.draw(canvas, (canvas.getWidth() - bmp.getWidth()) / 2, 0);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+
+        Log.i(TAG, "Finishing processing thread");
+    }
+}
\ No newline at end of file
diff --git a/android/apps/HelloAndroid/CMakeLists.txt b/samples/android/hello-android/CMakeLists.txt
similarity index 91%
rename from android/apps/HelloAndroid/CMakeLists.txt
rename to samples/android/hello-android/CMakeLists.txt
index c4c1d969f5..032d98369d 100644
--- a/android/apps/HelloAndroid/CMakeLists.txt
+++ b/samples/android/hello-android/CMakeLists.txt
@@ -8,7 +8,7 @@ IF( NOT PROJECT_NAME )
   IF ( NOT "x$ENV{PROJECT_NAME}" STREQUAL "x" )
     SET( PROJECT_NAME $ENV{PROJECT_NAME} )
   ELSE()
-    SET( PROJECT_NAME HelloAndroid )
+    SET( PROJECT_NAME hello-android )
   ENDIF()
 ENDIF()
 SET( PROJECT_NAME ${PROJECT_NAME} CACHE STRING "The name of your project")
@@ -19,7 +19,6 @@ PROJECT( ${PROJECT_NAME} )
 # Find OpenCV
 #########################################################
 
-SET( OpenCV_DIR ${CMAKE_SOURCE_DIR}/../../build CACHE PATH "The path where you built opencv for android" )
 FIND_PACKAGE( OpenCV REQUIRED )
 
 #########################################################
@@ -55,7 +54,7 @@ message( STATUS "")
 message( STATUS "General configuration for ${PROJECT_NAME} =====================================")
 message( STATUS "")
 message( STATUS "    OpenCV path:                ${OpenCV_DIR}")
-message( STATUS "    Compiler:                   ${CMAKE_COMPILER}")
+message( STATUS "    Compiler:                   ${CMAKE_CXX_COMPILER}")
 message( STATUS "    C++ flags (Release):        ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
 message( STATUS "    C++ flags (Debug):          ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
 if(WIN32)
diff --git a/samples/android/hello-android/cmake_android.cmd b/samples/android/hello-android/cmake_android.cmd
new file mode 100644
index 0000000000..e9daa27655
--- /dev/null
+++ b/samples/android/hello-android/cmake_android.cmd
@@ -0,0 +1,9 @@
+@ECHO OFF
+SETLOCAL
+PUSHD %~dp0
+SET PROJECT_NAME=hello-android
+SET BUILD_DIR=build_armeabi
+SET ARM_TARGET=armeabi
+CALL ..\..\..\android\scripts\build.cmd %*
+POPD
+ENDLOCAL
diff --git a/android/apps/HelloAndroid/cmake_android.sh b/samples/android/hello-android/cmake_android.sh
similarity index 88%
rename from android/apps/HelloAndroid/cmake_android.sh
rename to samples/android/hello-android/cmake_android.sh
index d724bf23eb..f233e302ee 100644
--- a/android/apps/HelloAndroid/cmake_android.sh
+++ b/samples/android/hello-android/cmake_android.sh
@@ -2,7 +2,7 @@
 cd `dirname $0`
 
 BUILD_DIR=build_armeabi
-opencv_android=`pwd`/../..
+opencv_android=`pwd`/../../../android
 opencv_build_dir=$opencv_android/$BUILD_DIR
 
 mkdir -p $BUILD_DIR
diff --git a/android/apps/HelloAndroid/main.cpp b/samples/android/hello-android/main.cpp
similarity index 100%
rename from android/apps/HelloAndroid/main.cpp
rename to samples/android/hello-android/main.cpp
diff --git a/android/apps/HelloAndroid/run.cmd b/samples/android/hello-android/run.cmd
similarity index 77%
rename from android/apps/HelloAndroid/run.cmd
rename to samples/android/hello-android/run.cmd
index f54b826a55..717d56d3fd 100644
--- a/android/apps/HelloAndroid/run.cmd
+++ b/samples/android/hello-android/run.cmd
@@ -15,12 +15,10 @@ SETLOCAL ENABLEEXTENSIONS || (ECHO Unable to enable command extensions. & EXIT \
 
 PUSHD %~dp0
 :: project specific settings
-SET PROJECT_NAME=HelloAndroid
-SET BUILD_DIR=build_armeabi
-SET ARM_TARGET=armeabi
+SET PROJECT_NAME=hello-android
 
 :: try to load config file
-SET CFG_PATH=..\..\scripts\wincfg.cmd
+SET CFG_PATH=..\..\..\android\scripts\wincfg.cmd
 IF EXIST %CFG_PATH% CALL %CFG_PATH%
 
 :: check if sdk path defined
@@ -28,11 +26,8 @@ IF NOT DEFINED ANDROID_SDK (ECHO. & ECHO You should set an environment variable
 (PUSHD "%ANDROID_SDK%" 2>NUL && POPD) || (ECHO. & ECHO Directory "%ANDROID_SDK%" specified by ANDROID_SDK variable does not exist & GOTO end)
 SET adb=%ANDROID_SDK%\platform-tools\adb.exe
 
-::binary output path is different for emulator build
-IF "%ARM_TARGET%"=="armeabi" (SET OUT_DIR=armeabi) ELSE (SET OUT_DIR=armeabi-v7a)
-
 :: copy file to device (usually takes 10 seconds or more)
-%adb% push .\bin\%OUT_DIR%\%PROJECT_NAME% /data/bin/sample/%PROJECT_NAME% || GOTO end
+%adb% push .\bin\%PROJECT_NAME% /data/bin/sample/%PROJECT_NAME% || GOTO end
 
 :: set execute permission
 %adb% shell chmod 777 /data/bin/sample/%PROJECT_NAME% || GOTO end
@@ -51,4 +46,4 @@ GOTO end
 
 :end
 POPD
-ENDLOCAL
\ No newline at end of file
+ENDLOCAL
diff --git a/android/apps/HelloAndroid/run.sh b/samples/android/hello-android/run.sh
similarity index 62%
rename from android/apps/HelloAndroid/run.sh
rename to samples/android/hello-android/run.sh
index 467a4a6a6d..1168c51df6 100644
--- a/android/apps/HelloAndroid/run.sh
+++ b/samples/android/hello-android/run.sh
@@ -1,10 +1,9 @@
 #!/bin/sh
 cd `dirname $0`
-PROJECT_NAME=HelloAndroid
-OUT_DIR=armeabi
+PROJECT_NAME=hello-android
 
 # copy file to device (usually takes 10 seconds or more)
-adb push ./bin/$OUT_DIR/$PROJECT_NAME /data/bin/sample/$PROJECT_NAME || return
+adb push ./bin/$PROJECT_NAME /data/bin/sample/$PROJECT_NAME || return
 
 # set execute permission
 adb shell chmod 777 /data/bin/sample/$PROJECT_NAME || return
@@ -13,4 +12,4 @@ adb shell chmod 777 /data/bin/sample/$PROJECT_NAME || return
 adb shell /data/bin/sample/$PROJECT_NAME || return
 
 # get image result from device
-adb pull /mnt/sdcard/HelloAndroid.png || return
\ No newline at end of file
+adb pull /mnt/sdcard/HelloAndroid.png || return
diff --git a/samples/android/image-manipulations/.classpath b/samples/android/image-manipulations/.classpath
new file mode 100644
index 0000000000..a0a90f9b1c
--- /dev/null
+++ b/samples/android/image-manipulations/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/image-manipulations/.project b/samples/android/image-manipulations/.project
new file mode 100644
index 0000000000..2920cef591
--- /dev/null
+++ b/samples/android/image-manipulations/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Sample - image-manipulations</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/image-manipulations/.settings/org.eclipse.jdt.core.prefs b/samples/android/image-manipulations/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/image-manipulations/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/image-manipulations/AndroidManifest.xml b/samples/android/image-manipulations/AndroidManifest.xml
new file mode 100644
index 0000000000..ab3200318b
--- /dev/null
+++ b/samples/android/image-manipulations/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.imagemanipulations"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="ImageManipulationsActivity"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/image-manipulations/default.properties b/samples/android/image-manipulations/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/samples/android/image-manipulations/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/samples/android/image-manipulations/res/drawable/icon.png b/samples/android/image-manipulations/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/image-manipulations/res/drawable/icon.png differ
diff --git a/samples/android/image-manipulations/res/values/strings.xml b/samples/android/image-manipulations/res/values/strings.xml
new file mode 100644
index 0000000000..528144eb45
--- /dev/null
+++ b/samples/android/image-manipulations/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">OpenCV Sample - image-manipulations</string>
+</resources>
diff --git a/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/FpsMeter.java b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/FpsMeter.java
new file mode 100644
index 0000000000..f00865427b
--- /dev/null
+++ b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/FpsMeter.java
@@ -0,0 +1,50 @@
+package org.opencv.samples.imagemanipulations;
+
+import java.text.DecimalFormat;
+
+import org.opencv.core.Core;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.util.Log;
+
+public class FpsMeter {
+    private static final String TAG       = "Sample::FpsMeter";
+    int                         step;
+    int                         framesCouner;
+    double                      freq;
+    long                        prevFrameTime;
+    String                      strfps;
+    DecimalFormat               twoPlaces = new DecimalFormat("0.00");
+    Paint                       paint;
+
+    public void init() {
+        step = 20;
+        framesCouner = 0;
+        freq = Core.getTickFrequency();
+        prevFrameTime = Core.getTickCount();
+        strfps = "";
+
+        paint = new Paint();
+        paint.setColor(Color.BLUE);
+        paint.setTextSize(50);
+    }
+
+    public void measure() {
+        framesCouner++;
+        if (framesCouner % step == 0) {
+            long time = Core.getTickCount();
+            double fps = step * freq / (time - prevFrameTime);
+            prevFrameTime = time;
+            DecimalFormat twoPlaces = new DecimalFormat("0.00");
+            strfps = twoPlaces.format(fps) + " FPS";
+            Log.i(TAG, strfps);
+        }
+    }
+
+    public void draw(Canvas canvas, float offsetx, float offsety) {
+        canvas.drawText(strfps, 20 + offsetx, 10 + 50 + offsety, paint);
+    }
+
+}
diff --git a/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java
new file mode 100644
index 0000000000..d41f980ad6
--- /dev/null
+++ b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsActivity.java
@@ -0,0 +1,71 @@
+package org.opencv.samples.imagemanipulations;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class ImageManipulationsActivity extends Activity {
+    private static final String TAG             = "Sample::Activity";
+
+    public static final int     VIEW_MODE_RGBA  = 0;
+    public static final int     VIEW_MODE_CANNY = 1;
+    public static final int     VIEW_MODE_SEPIA = 2;
+    public static final int     VIEW_MODE_SOBEL = 3;
+    public static final int     VIEW_MODE_BLUR  = 4;
+    public static final int     VIEW_MODE_ZOOM  = 5;
+
+    private MenuItem            mItemPreviewRGBA;
+    private MenuItem            mItemPreviewCanny;
+    private MenuItem            mItemPreviewSepia;
+    private MenuItem            mItemPreviewSobel;
+    private MenuItem            mItemPreviewBlur;
+    private MenuItem            mItemPreviewZoom;
+
+    public static int           viewMode        = VIEW_MODE_RGBA;
+
+    public ImageManipulationsActivity() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new ImageManipulationsView(this));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewCanny = menu.add("Canny");
+        mItemPreviewSepia = menu.add("Sepia");
+        mItemPreviewSobel = menu.add("Sobel");
+        mItemPreviewBlur = menu.add("Blur");
+        mItemPreviewZoom = menu.add("Zoom");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        else if (item == mItemPreviewCanny)
+            viewMode = VIEW_MODE_CANNY;
+        else if (item == mItemPreviewSepia)
+            viewMode = VIEW_MODE_SEPIA;
+        else if (item == mItemPreviewSobel)
+            viewMode = VIEW_MODE_SOBEL;
+        else if (item == mItemPreviewBlur)
+            viewMode = VIEW_MODE_BLUR;
+        else if (item == mItemPreviewZoom)
+            viewMode = VIEW_MODE_ZOOM;
+        return true;
+    }
+}
diff --git a/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsView.java b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsView.java
new file mode 100644
index 0000000000..d4f74cf8fa
--- /dev/null
+++ b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/ImageManipulationsView.java
@@ -0,0 +1,178 @@
+package org.opencv.samples.imagemanipulations;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.CvType;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.SurfaceHolder;
+
+class ImageManipulationsView extends SampleCvViewBase {
+    private Mat mRgba;
+    private Mat mGray;
+    private Mat mIntermediateMat;
+
+    private Mat mRgbaInnerWindow;
+    private Mat mGrayInnerWindow;
+    private Mat mBlurWindow;
+    private Mat mZoomWindow;
+    private Mat mZoomCorner;
+
+    private Mat mSepiaKernel;
+
+    public ImageManipulationsView(Context context) {
+        super(context);
+
+        mSepiaKernel = new Mat(4, 4, CvType.CV_32F);
+        mSepiaKernel.put(0, 0, /* R */0.189f, 0.769f, 0.393f, 0f);
+        mSepiaKernel.put(1, 0, /* G */0.168f, 0.686f, 0.349f, 0f);
+        mSepiaKernel.put(2, 0, /* B */0.131f, 0.534f, 0.272f, 0f);
+        mSepiaKernel.put(3, 0, /* A */0.000f, 0.000f, 0.000f, 1f);
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+
+        synchronized (this) {
+            // initialize Mats before usage
+            mGray = new Mat();
+            mRgba = new Mat();
+            mIntermediateMat = new Mat();
+        }
+    }
+
+    private void CreateAuxiliaryMats() {
+        if (mRgba.empty())
+            return;
+
+        int rows = mRgba.rows();
+        int cols = mRgba.cols();
+
+        int left = cols / 8;
+        int top = rows / 8;
+
+        int width = cols * 3 / 4;
+        int height = rows * 3 / 4;
+
+        if (mRgbaInnerWindow == null)
+            mRgbaInnerWindow = mRgba.submat(top, top + height, left, left + width);
+
+        if (mGrayInnerWindow == null && !mGray.empty())
+            mGrayInnerWindow = mGray.submat(top, top + height, left, left + width);
+
+        if (mBlurWindow == null)
+            mBlurWindow = mRgba.submat(0, rows, cols / 3, cols * 2 / 3);
+
+        if (mZoomCorner == null)
+            mZoomCorner = mRgba.submat(0, rows / 2 - rows / 10, 0, cols / 2 - cols / 10);
+
+        if (mZoomWindow == null)
+            mZoomWindow = mRgba.submat(rows / 2 - 9 * rows / 100, rows / 2 + 9 * rows / 100, cols / 2 - 9 * cols / 100, cols / 2 + 9 * cols / 100);
+    }
+
+    @Override
+    protected Bitmap processFrame(VideoCapture capture) {
+        switch (ImageManipulationsActivity.viewMode) {
+
+        case ImageManipulationsActivity.VIEW_MODE_RGBA:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_CANNY:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+
+            if (mRgbaInnerWindow == null || mGrayInnerWindow == null)
+                CreateAuxiliaryMats();
+
+            Imgproc.Canny(mGrayInnerWindow, mGrayInnerWindow, 80, 90);
+            Imgproc.cvtColor(mGrayInnerWindow, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_SOBEL:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+
+            if (mRgbaInnerWindow == null || mGrayInnerWindow == null)
+                CreateAuxiliaryMats();
+
+            Imgproc.Sobel(mGrayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1);
+            Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10);
+            Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4);
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_SEPIA:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            Core.transform(mRgba, mRgba, mSepiaKernel);
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_BLUR:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            if (mBlurWindow == null)
+                CreateAuxiliaryMats();
+            Imgproc.blur(mBlurWindow, mBlurWindow, new Size(15, 15));
+            break;
+
+        case ImageManipulationsActivity.VIEW_MODE_ZOOM:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            if (mZoomCorner == null || mZoomWindow == null)
+                CreateAuxiliaryMats();
+            Imgproc.resize(mZoomWindow, mZoomCorner, mZoomCorner.size());
+
+            Size wsize = mZoomWindow.size();
+            Core.rectangle(mZoomWindow, new Point(1, 1), new Point(wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0, 255), 2);
+            break;
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
+
+        if (Utils.matToBitmap(mRgba, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mZoomWindow != null)
+                mZoomWindow.release();
+            if (mZoomCorner != null)
+                mZoomCorner.release();
+            if (mBlurWindow != null)
+                mBlurWindow.release();
+            if (mGrayInnerWindow != null)
+                mGrayInnerWindow.release();
+            if (mRgbaInnerWindow != null)
+                mRgbaInnerWindow.release();
+            if (mRgba != null)
+                mRgba.release();
+            if (mGray != null)
+                mGray.release();
+            if (mIntermediateMat != null)
+                mIntermediateMat.release();
+
+            mRgba = null;
+            mGray = null;
+            mIntermediateMat = null;
+            mRgbaInnerWindow = null;
+            mGrayInnerWindow = null;
+            mBlurWindow = null;
+            mZoomCorner = null;
+            mZoomWindow = null;
+        }
+    }
+}
diff --git a/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/SampleCvViewBase.java b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/SampleCvViewBase.java
new file mode 100644
index 0000000000..27ef613627
--- /dev/null
+++ b/samples/android/image-manipulations/src/org/opencv/samples/imagemanipulations/SampleCvViewBase.java
@@ -0,0 +1,117 @@
+package org.opencv.samples.imagemanipulations;
+
+import java.util.List;
+
+import org.opencv.core.Size;
+import org.opencv.highgui.VideoCapture;
+import org.opencv.highgui.Highgui;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private SurfaceHolder       mHolder;
+    private VideoCapture        mCamera;
+    private FpsMeter            mFps;
+
+    public SampleCvViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        mFps = new FpsMeter();
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        synchronized (this) {
+            if (mCamera != null && mCamera.isOpened()) {
+                Log.i(TAG, "before mCamera.getSupportedPreviewSizes()");
+                List<Size> sizes = mCamera.getSupportedPreviewSizes();
+                Log.i(TAG, "after mCamera.getSupportedPreviewSizes()");
+                int mFrameWidth = width;
+                int mFrameHeight = height;
+
+                // selecting optimal camera preview size
+                {
+                    double minDiff = Double.MAX_VALUE;
+                    for (Size size : sizes) {
+                        if (Math.abs(size.height - height) < minDiff) {
+                            mFrameWidth = (int) size.width;
+                            mFrameHeight = (int) size.height;
+                            minDiff = Math.abs(size.height - height);
+                        }
+                    }
+                }
+
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
+            }
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+        if (mCamera.isOpened()) {
+            (new Thread(this)).start();
+        } else {
+            mCamera.release();
+            mCamera = null;
+            Log.e(TAG, "Failed to open native camera");
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(VideoCapture capture);
+
+    public void run() {
+        Log.i(TAG, "Starting processing thread");
+        mFps.init();
+
+        while (true) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                if (mCamera == null)
+                    break;
+
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "mCamera.grab() failed");
+                    break;
+                }
+
+                bmp = processFrame(mCamera);
+
+                mFps.measure();
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
+                    mFps.draw(canvas, (canvas.getWidth() - bmp.getWidth()) / 2, 0);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+
+        Log.i(TAG, "Finishing processing thread");
+    }
+}
\ No newline at end of file
diff --git a/samples/android/includeOpenCV.mk b/samples/android/includeOpenCV.mk
new file mode 100644
index 0000000000..9391e59306
--- /dev/null
+++ b/samples/android/includeOpenCV.mk
@@ -0,0 +1 @@
+OPENCV_MK_PATH:=../../../android/build/OpenCV.mk
diff --git a/samples/android/tutorial-0-androidcamera/.classpath b/samples/android/tutorial-0-androidcamera/.classpath
new file mode 100644
index 0000000000..6e9239ff0d
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/tutorial-0-androidcamera/.project b/samples/android/tutorial-0-androidcamera/.project
new file mode 100644
index 0000000000..61dd3d5264
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/.project
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Tutorial 1 Basic - 0. Android Camera</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/samples/android/tutorial-0-androidcamera/.settings/org.eclipse.jdt.core.prefs b/samples/android/tutorial-0-androidcamera/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/tutorial-0-androidcamera/AndroidManifest.xml b/samples/android/tutorial-0-androidcamera/AndroidManifest.xml
new file mode 100644
index 0000000000..ddfcd5a616
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.tutorial0"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="Sample0Base"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/tutorial-0-androidcamera/default.properties b/samples/android/tutorial-0-androidcamera/default.properties
new file mode 100644
index 0000000000..32299c258a
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/default.properties
@@ -0,0 +1,2 @@
+# Project target.
+target=android-8
diff --git a/samples/android/tutorial-0-androidcamera/res/drawable/icon.png b/samples/android/tutorial-0-androidcamera/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/tutorial-0-androidcamera/res/drawable/icon.png differ
diff --git a/samples/android/tutorial-0-androidcamera/res/values/strings.xml b/samples/android/tutorial-0-androidcamera/res/values/strings.xml
new file mode 100644
index 0000000000..0423b8c67d
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Tutorial 1 Basic - 0. Android Camera</string>
+</resources>
diff --git a/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0Base.java b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0Base.java
new file mode 100644
index 0000000000..f49b3587d5
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0Base.java
@@ -0,0 +1,51 @@
+package org.opencv.samples.tutorial0;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class Sample0Base extends Activity {
+    private static final String TAG            = "Sample::Activity";
+
+    public static final int     VIEW_MODE_RGBA = 0;
+    public static final int     VIEW_MODE_GRAY = 1;
+
+    private MenuItem            mItemPreviewRGBA;
+    private MenuItem            mItemPreviewGray;
+
+    public static int           viewMode       = VIEW_MODE_RGBA;
+
+    public Sample0Base() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new Sample0View(this));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewGray = menu.add("Preview GRAY");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        else if (item == mItemPreviewGray)
+            viewMode = VIEW_MODE_GRAY;
+        return true;
+    }
+}
diff --git a/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0View.java b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0View.java
new file mode 100644
index 0000000000..b167230160
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/Sample0View.java
@@ -0,0 +1,46 @@
+package org.opencv.samples.tutorial0;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+class Sample0View extends SampleViewBase {
+    public Sample0View(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected Bitmap processFrame(byte[] data) {
+        int frameSize = getFrameWidth() * getFrameHeight();
+        int[] rgba = new int[frameSize];
+
+        int view_mode = Sample0Base.viewMode;
+        if (view_mode == Sample0Base.VIEW_MODE_GRAY) {
+            for (int i = 0; i < frameSize; i++) {
+                int y = (0xff & ((int) data[i]));
+                rgba[i] = 0xff000000 + (y << 16) + (y << 8) + y;
+            }
+        } else if (view_mode == Sample0Base.VIEW_MODE_RGBA) {
+            for (int i = 0; i < getFrameHeight(); i++)
+                for (int j = 0; j < getFrameWidth(); j++) {
+                    int y = (0xff & ((int) data[i * getFrameWidth() + j]));
+                    int u = (0xff & ((int) data[frameSize + (i >> 1) * getFrameWidth() + (j & ~1) + 0]));
+                    int v = (0xff & ((int) data[frameSize + (i >> 1) * getFrameWidth() + (j & ~1) + 1]));
+                    y = y < 16 ? 16 : y;
+
+                    int r = Math.round(1.164f * (y - 16) + 1.596f * (v - 128));
+                    int g = Math.round(1.164f * (y - 16) - 0.813f * (v - 128) - 0.391f * (u - 128));
+                    int b = Math.round(1.164f * (y - 16) + 2.018f * (u - 128));
+
+                    r = r < 0 ? 0 : (r > 255 ? 255 : r);
+                    g = g < 0 ? 0 : (g > 255 ? 255 : g);
+                    b = b < 0 ? 0 : (b > 255 ? 255 : b);
+
+                    rgba[i * getFrameWidth() + j] = 0xff000000 + (b << 16) + (g << 8) + r;
+                }
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(getFrameWidth(), getFrameHeight(), Bitmap.Config.ARGB_8888);
+        bmp.setPixels(rgba, 0/* offset */, getFrameWidth() /* stride */, 0, 0, getFrameWidth(), getFrameHeight());
+        return bmp;
+    }
+}
\ No newline at end of file
diff --git a/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/SampleViewBase.java b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/SampleViewBase.java
new file mode 100644
index 0000000000..05800baff5
--- /dev/null
+++ b/samples/android/tutorial-0-androidcamera/src/org/opencv/samples/tutorial0/SampleViewBase.java
@@ -0,0 +1,125 @@
+package org.opencv.samples.tutorial0;
+
+import java.io.IOException;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.hardware.Camera;
+import android.hardware.Camera.PreviewCallback;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private Camera              mCamera;
+    private SurfaceHolder       mHolder;
+    private int                 mFrameWidth;
+    private int                 mFrameHeight;
+    private byte[]              mFrame;
+    private boolean             mThreadRun;
+
+    public SampleViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public int getFrameWidth() {
+        return mFrameWidth;
+    }
+
+    public int getFrameHeight() {
+        return mFrameHeight;
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        if (mCamera != null) {
+            Camera.Parameters params = mCamera.getParameters();
+            List<Camera.Size> sizes = params.getSupportedPreviewSizes();
+            mFrameWidth = width;
+            mFrameHeight = height;
+
+            // selecting optimal camera preview size
+            {
+                double minDiff = Double.MAX_VALUE;
+                for (Camera.Size size : sizes) {
+                    if (Math.abs(size.height - height) < minDiff) {
+                        mFrameWidth = size.width;
+                        mFrameHeight = size.height;
+                        minDiff = Math.abs(size.height - height);
+                    }
+                }
+            }
+
+            params.setPreviewSize(getFrameWidth(), getFrameHeight());
+            mCamera.setParameters(params);
+            try {
+				mCamera.setPreviewDisplay(null);
+			} catch (IOException e) {
+				Log.e(TAG, "mCamera.setPreviewDisplay fails: " + e);
+			}
+            mCamera.startPreview();
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = Camera.open();
+        mCamera.setPreviewCallback(new PreviewCallback() {
+            public void onPreviewFrame(byte[] data, Camera camera) {
+                synchronized (SampleViewBase.this) {
+                    mFrame = data;
+                    SampleViewBase.this.notify();
+                }
+            }
+        });
+        (new Thread(this)).start();
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        mThreadRun = false;
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.stopPreview();
+                mCamera.setPreviewCallback(null);
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(byte[] data);
+
+    public void run() {
+        mThreadRun = true;
+        Log.i(TAG, "Starting processing thread");
+        while (mThreadRun) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                try {
+                    this.wait();
+                    bmp = processFrame(mFrame);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - getFrameWidth()) / 2, (canvas.getHeight() - getFrameHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/samples/android/tutorial-1-addopencv/.classpath b/samples/android/tutorial-1-addopencv/.classpath
new file mode 100644
index 0000000000..a0a90f9b1c
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/tutorial-1-addopencv/.project b/samples/android/tutorial-1-addopencv/.project
new file mode 100644
index 0000000000..90ff95b55b
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Tutorial 1 Basic - 1. Add OpenCV</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/tutorial-1-addopencv/.settings/org.eclipse.jdt.core.prefs b/samples/android/tutorial-1-addopencv/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/tutorial-1-addopencv/AndroidManifest.xml b/samples/android/tutorial-1-addopencv/AndroidManifest.xml
new file mode 100644
index 0000000000..438f096243
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.tutorial1"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="Sample1Java"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/tutorial-1-addopencv/default.properties b/samples/android/tutorial-1-addopencv/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/samples/android/tutorial-1-addopencv/res/drawable/icon.png b/samples/android/tutorial-1-addopencv/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/tutorial-1-addopencv/res/drawable/icon.png differ
diff --git a/samples/android/tutorial-1-addopencv/res/values/strings.xml b/samples/android/tutorial-1-addopencv/res/values/strings.xml
new file mode 100644
index 0000000000..04fe435d12
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Tutorial 1 Basic - 1. Add OpenCV</string>
+</resources>
diff --git a/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1Java.java b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1Java.java
new file mode 100644
index 0000000000..f05ee333d9
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1Java.java
@@ -0,0 +1,56 @@
+package org.opencv.samples.tutorial1;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class Sample1Java extends Activity {
+    private static final String TAG             = "Sample::Activity";
+
+    public static final int     VIEW_MODE_RGBA  = 0;
+    public static final int     VIEW_MODE_GRAY  = 1;
+    public static final int     VIEW_MODE_CANNY = 2;
+
+    private MenuItem            mItemPreviewRGBA;
+    private MenuItem            mItemPreviewGray;
+    private MenuItem            mItemPreviewCanny;
+
+    public static int           viewMode        = VIEW_MODE_RGBA;
+
+    public Sample1Java() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new Sample1View(this));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewGray = menu.add("Preview GRAY");
+        mItemPreviewCanny = menu.add("Canny");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        else if (item == mItemPreviewGray)
+            viewMode = VIEW_MODE_GRAY;
+        else if (item == mItemPreviewCanny)
+            viewMode = VIEW_MODE_CANNY;
+        return true;
+    }
+}
diff --git a/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1View.java b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1View.java
new file mode 100644
index 0000000000..32aa634699
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/Sample1View.java
@@ -0,0 +1,87 @@
+package org.opencv.samples.tutorial1;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.CvType;
+import org.opencv.imgproc.Imgproc;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.SurfaceHolder;
+
+class Sample1View extends SampleViewBase {
+    private Mat mYuv;
+    private Mat mRgba;
+    private Mat mGraySubmat;
+    private Mat mIntermediateMat;
+
+    public Sample1View(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+
+        synchronized (this) {
+            // initialize Mats before usage
+            mYuv = new Mat(getFrameHeight() + getFrameHeight() / 2, getFrameWidth(), CvType.CV_8UC1);
+            mGraySubmat = mYuv.submat(0, getFrameHeight(), 0, getFrameWidth());
+
+            mRgba = new Mat();
+            mIntermediateMat = new Mat();
+        }
+    }
+
+    @Override
+    protected Bitmap processFrame(byte[] data) {
+        mYuv.put(0, 0, data);
+
+        switch (Sample1Java.viewMode) {
+        case Sample1Java.VIEW_MODE_GRAY:
+            Imgproc.cvtColor(mGraySubmat, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            break;
+        case Sample1Java.VIEW_MODE_RGBA:
+            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
+            Core.putText(mRgba, "OpenCV + Android", new Point(10, 100), 3/* CV_FONT_HERSHEY_COMPLEX */, 2, new Scalar(255, 0, 0, 255), 3);
+            break;
+        case Sample1Java.VIEW_MODE_CANNY:
+            Imgproc.Canny(mGraySubmat, mIntermediateMat, 80, 100);
+            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
+            break;
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(getFrameWidth(), getFrameHeight(), Bitmap.Config.ARGB_8888);
+
+        if (Utils.matToBitmap(mRgba, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mYuv != null)
+                mYuv.release();
+            if (mRgba != null)
+                mRgba.release();
+            if (mGraySubmat != null)
+                mGraySubmat.release();
+            if (mIntermediateMat != null)
+                mIntermediateMat.release();
+
+            mYuv = null;
+            mRgba = null;
+            mGraySubmat = null;
+            mIntermediateMat = null;
+        }
+    }
+}
diff --git a/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/SampleViewBase.java b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/SampleViewBase.java
new file mode 100644
index 0000000000..45f39d0ca4
--- /dev/null
+++ b/samples/android/tutorial-1-addopencv/src/org/opencv/samples/tutorial1/SampleViewBase.java
@@ -0,0 +1,125 @@
+package org.opencv.samples.tutorial1;
+
+import java.io.IOException;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.hardware.Camera;
+import android.hardware.Camera.PreviewCallback;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private Camera              mCamera;
+    private SurfaceHolder       mHolder;
+    private int                 mFrameWidth;
+    private int                 mFrameHeight;
+    private byte[]              mFrame;
+    private boolean             mThreadRun;
+
+    public SampleViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public int getFrameWidth() {
+        return mFrameWidth;
+    }
+
+    public int getFrameHeight() {
+        return mFrameHeight;
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        if (mCamera != null) {
+            Camera.Parameters params = mCamera.getParameters();
+            List<Camera.Size> sizes = params.getSupportedPreviewSizes();
+            mFrameWidth = width;
+            mFrameHeight = height;
+
+            // selecting optimal camera preview size
+            {
+                double minDiff = Double.MAX_VALUE;
+                for (Camera.Size size : sizes) {
+                    if (Math.abs(size.height - height) < minDiff) {
+                        mFrameWidth = size.width;
+                        mFrameHeight = size.height;
+                        minDiff = Math.abs(size.height - height);
+                    }
+                }
+            }
+
+            params.setPreviewSize(getFrameWidth(), getFrameHeight());
+            mCamera.setParameters(params);
+            try {
+				mCamera.setPreviewDisplay(null);
+			} catch (IOException e) {
+				Log.e(TAG, "mCamera.setPreviewDisplay fails: " + e);
+			}
+            mCamera.startPreview();
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = Camera.open();
+        mCamera.setPreviewCallback(new PreviewCallback() {
+            public void onPreviewFrame(byte[] data, Camera camera) {
+                synchronized (SampleViewBase.this) {
+                    mFrame = data;
+                    SampleViewBase.this.notify();
+                }
+            }
+        });
+        (new Thread(this)).start();
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        mThreadRun = false;
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.stopPreview();
+                mCamera.setPreviewCallback(null);
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(byte[] data);
+
+    public void run() {
+        mThreadRun = true;
+        Log.i(TAG, "Starting processing thread");
+        while (mThreadRun) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                try {
+                    this.wait();
+                    bmp = processFrame(mFrame);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - getFrameWidth()) / 2, (canvas.getHeight() - getFrameHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/samples/android/tutorial-2-opencvcamera/.classpath b/samples/android/tutorial-2-opencvcamera/.classpath
new file mode 100644
index 0000000000..a0a90f9b1c
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/tutorial-2-opencvcamera/.project b/samples/android/tutorial-2-opencvcamera/.project
new file mode 100644
index 0000000000..5f1ca2cf5f
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Tutorial 1 Basic - 2. Use OpenCV Camera</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/tutorial-2-opencvcamera/.settings/org.eclipse.jdt.core.prefs b/samples/android/tutorial-2-opencvcamera/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/tutorial-2-opencvcamera/AndroidManifest.xml b/samples/android/tutorial-2-opencvcamera/AndroidManifest.xml
new file mode 100644
index 0000000000..accc3b2cf9
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.tutorial2"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="Sample2NativeCamera"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/tutorial-2-opencvcamera/default.properties b/samples/android/tutorial-2-opencvcamera/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/samples/android/tutorial-2-opencvcamera/res/drawable/icon.png b/samples/android/tutorial-2-opencvcamera/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/tutorial-2-opencvcamera/res/drawable/icon.png differ
diff --git a/samples/android/tutorial-2-opencvcamera/res/values/strings.xml b/samples/android/tutorial-2-opencvcamera/res/values/strings.xml
new file mode 100644
index 0000000000..51f727c30d
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Tutorial 1 Basic - 2. Use OpenCV Camera</string>
+</resources>
diff --git a/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2NativeCamera.java b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2NativeCamera.java
new file mode 100644
index 0000000000..de3fbb5df8
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2NativeCamera.java
@@ -0,0 +1,56 @@
+package org.opencv.samples.tutorial2;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class Sample2NativeCamera extends Activity {
+    private static final String TAG             = "Sample::Activity";
+
+    public static final int     VIEW_MODE_RGBA  = 0;
+    public static final int     VIEW_MODE_GRAY  = 1;
+    public static final int     VIEW_MODE_CANNY = 2;
+
+    private MenuItem            mItemPreviewRGBA;
+    private MenuItem            mItemPreviewGray;
+    private MenuItem            mItemPreviewCanny;
+
+    public static int           viewMode        = VIEW_MODE_RGBA;
+
+    public Sample2NativeCamera() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new Sample2View(this));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewGray = menu.add("Preview GRAY");
+        mItemPreviewCanny = menu.add("Canny");
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        else if (item == mItemPreviewGray)
+            viewMode = VIEW_MODE_GRAY;
+        else if (item == mItemPreviewCanny)
+            viewMode = VIEW_MODE_CANNY;
+        return true;
+    }
+}
diff --git a/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2View.java b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2View.java
new file mode 100644
index 0000000000..bbadc5ef34
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/Sample2View.java
@@ -0,0 +1,82 @@
+package org.opencv.samples.tutorial2;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.highgui.Highgui;
+import org.opencv.highgui.VideoCapture;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.SurfaceHolder;
+
+class Sample2View extends SampleCvViewBase {
+    private Mat mRgba;
+    private Mat mGray;
+    private Mat mIntermediateMat;
+
+    public Sample2View(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+
+        synchronized (this) {
+            // initialize Mats before usage
+            mGray = new Mat();
+            mRgba = new Mat();
+            mIntermediateMat = new Mat();
+        }
+    }
+
+    @Override
+    protected Bitmap processFrame(VideoCapture capture) {
+        switch (Sample2NativeCamera.viewMode) {
+        case Sample2NativeCamera.VIEW_MODE_GRAY:
+            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+            Imgproc.cvtColor(mGray, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            break;
+        case Sample2NativeCamera.VIEW_MODE_RGBA:
+            capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
+            Core.putText(mRgba, "OpenCV + Android", new Point(10, 100), 3/* CV_FONT_HERSHEY_COMPLEX */, 2, new Scalar(255, 0, 0, 255), 3);
+            break;
+        case Sample2NativeCamera.VIEW_MODE_CANNY:
+            capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
+            Imgproc.Canny(mGray, mIntermediateMat, 80, 100);
+            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
+            break;
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
+
+        if (Utils.matToBitmap(mRgba, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mRgba != null)
+                mRgba.release();
+            if (mGray != null)
+                mGray.release();
+            if (mIntermediateMat != null)
+                mIntermediateMat.release();
+
+            mRgba = null;
+            mGray = null;
+            mIntermediateMat = null;
+        }
+    }
+}
diff --git a/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/SampleCvViewBase.java b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/SampleCvViewBase.java
new file mode 100644
index 0000000000..cc0e54dc25
--- /dev/null
+++ b/samples/android/tutorial-2-opencvcamera/src/org/opencv/samples/tutorial2/SampleCvViewBase.java
@@ -0,0 +1,110 @@
+package org.opencv.samples.tutorial2;
+
+import java.util.List;
+
+import org.opencv.core.Size;
+import org.opencv.highgui.VideoCapture;
+import org.opencv.highgui.Highgui;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleCvViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private SurfaceHolder       mHolder;
+    private VideoCapture        mCamera;
+
+    public SampleCvViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        synchronized (this) {
+            if (mCamera != null && mCamera.isOpened()) {
+                Log.i(TAG, "before mCamera.getSupportedPreviewSizes()");
+                List<Size> sizes = mCamera.getSupportedPreviewSizes();
+                Log.i(TAG, "after mCamera.getSupportedPreviewSizes()");
+                int mFrameWidth = width;
+                int mFrameHeight = height;
+
+                // selecting optimal camera preview size
+                {
+                    double minDiff = Double.MAX_VALUE;
+                    for (Size size : sizes) {
+                        if (Math.abs(size.height - height) < minDiff) {
+                            mFrameWidth = (int) size.width;
+                            mFrameHeight = (int) size.height;
+                            minDiff = Math.abs(size.height - height);
+                        }
+                    }
+                }
+
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, mFrameWidth);
+                mCamera.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, mFrameHeight);
+            }
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID);
+        if (mCamera.isOpened()) {
+            (new Thread(this)).start();
+        } else {
+            mCamera.release();
+            mCamera = null;
+            Log.e(TAG, "Failed to open native camera");
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(VideoCapture capture);
+
+    public void run() {
+        Log.i(TAG, "Starting processing thread");
+        while (true) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                if (mCamera == null)
+                    break;
+
+                if (!mCamera.grab()) {
+                    Log.e(TAG, "mCamera.grab() failed");
+                    break;
+                }
+
+                bmp = processFrame(mCamera);
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - bmp.getWidth()) / 2, (canvas.getHeight() - bmp.getHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+
+        Log.i(TAG, "Finishing processing thread");
+    }
+}
\ No newline at end of file
diff --git a/samples/android/tutorial-3-native/.classpath b/samples/android/tutorial-3-native/.classpath
new file mode 100644
index 0000000000..609aa00ebc
--- /dev/null
+++ b/samples/android/tutorial-3-native/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/tutorial-3-native/.project b/samples/android/tutorial-3-native/.project
new file mode 100644
index 0000000000..6cf7ad3f2c
--- /dev/null
+++ b/samples/android/tutorial-3-native/.project
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Tutorial 2 Advanced - 1. Add Native OpenCV</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.ui.externaltools.ExternalToolBuilder</name>
+			<triggers>auto,full,incremental,</triggers>
+			<arguments>
+				<dictionary>
+					<key>LaunchConfigHandle</key>
+					<value>&lt;project&gt;/.externalToolBuilders/Tutorial 2.1 Builder.launch</value>
+				</dictionary>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/samples/android/tutorial-3-native/.settings/org.eclipse.jdt.core.prefs b/samples/android/tutorial-3-native/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/tutorial-3-native/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/tutorial-3-native/AndroidManifest.xml b/samples/android/tutorial-3-native/AndroidManifest.xml
new file mode 100644
index 0000000000..145048e7fc
--- /dev/null
+++ b/samples/android/tutorial-3-native/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.tutorial3"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="Sample3Native"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/tutorial-3-native/default.properties b/samples/android/tutorial-3-native/default.properties
new file mode 100644
index 0000000000..32299c258a
--- /dev/null
+++ b/samples/android/tutorial-3-native/default.properties
@@ -0,0 +1,2 @@
+# Project target.
+target=android-8
diff --git a/samples/android/tutorial-3-native/jni/Android.mk b/samples/android/tutorial-3-native/jni/Android.mk
new file mode 100644
index 0000000000..a9e302b473
--- /dev/null
+++ b/samples/android/tutorial-3-native/jni/Android.mk
@@ -0,0 +1,17 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+include ../includeOpenCV.mk
+ifeq ("$(wildcard $(OPENCV_MK_PATH))","")
+	#try to load OpenCV.mk from default install location
+	include $(TOOLCHAIN_PREBUILT_ROOT)/user/share/OpenCV/OpenCV.mk
+else
+	include $(OPENCV_MK_PATH)
+endif
+
+LOCAL_MODULE    := native_sample
+LOCAL_SRC_FILES := jni_part.cpp
+LOCAL_LDLIBS +=  -llog -ldl
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/samples/android/tutorial-3-native/jni/Application.mk b/samples/android/tutorial-3-native/jni/Application.mk
new file mode 100644
index 0000000000..c7de9c761b
--- /dev/null
+++ b/samples/android/tutorial-3-native/jni/Application.mk
@@ -0,0 +1,3 @@
+APP_STL := gnustl_static
+APP_CPPFLAGS := -frtti -fexceptions
+APP_ABI := armeabi-v7a
diff --git a/samples/android/tutorial-3-native/jni/jni_part.cpp b/samples/android/tutorial-3-native/jni/jni_part.cpp
new file mode 100644
index 0000000000..1a2b53d3c8
--- /dev/null
+++ b/samples/android/tutorial-3-native/jni/jni_part.cpp
@@ -0,0 +1,35 @@
+#include <jni.h>
+#include <opencv2/core/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/features2d/features2d.hpp>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+extern "C" {
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial3_Sample3View_FindFeatures(JNIEnv* env, jobject thiz, jint width, jint height, jbyteArray yuv, jintArray bgra)
+{
+    jbyte* _yuv  = env->GetByteArrayElements(yuv, 0);
+    jint*  _bgra = env->GetIntArrayElements(bgra, 0);
+
+    Mat myuv(height + height/2, width, CV_8UC1, (unsigned char *)_yuv);
+    Mat mbgra(height, width, CV_8UC4, (unsigned char *)_bgra);
+    Mat mgray(height, width, CV_8UC1, (unsigned char *)_yuv);
+
+    //Please make attention about BGRA byte order
+    //ARGB stored in java as int array becomes BGRA at native level
+    cvtColor(myuv, mbgra, CV_YUV420sp2BGR, 4);
+
+    vector<KeyPoint> v;
+
+    FastFeatureDetector detector(50);
+    detector.detect(mgray, v);
+    for( size_t i = 0; i < v.size(); i++ )
+        circle(mbgra, Point(v[i].pt.x, v[i].pt.y), 10, Scalar(0,0,255,255));
+
+    env->ReleaseIntArrayElements(bgra, _bgra, 0);
+    env->ReleaseByteArrayElements(yuv, _yuv, 0);
+}
+
+}
diff --git a/samples/android/tutorial-3-native/res/drawable/icon.png b/samples/android/tutorial-3-native/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/tutorial-3-native/res/drawable/icon.png differ
diff --git a/samples/android/tutorial-3-native/res/values/strings.xml b/samples/android/tutorial-3-native/res/values/strings.xml
new file mode 100644
index 0000000000..7552751586
--- /dev/null
+++ b/samples/android/tutorial-3-native/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Tutorial 2 Advanced - 1. Add Native OpenCV</string>
+</resources>
diff --git a/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3Native.java b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3Native.java
new file mode 100644
index 0000000000..e13ee140ae
--- /dev/null
+++ b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3Native.java
@@ -0,0 +1,23 @@
+package org.opencv.samples.tutorial3;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Window;
+
+public class Sample3Native extends Activity {
+    private static final String TAG = "Sample::Activity";
+
+    public Sample3Native() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        Log.i(TAG, "onCreate");
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new Sample3View(this));
+    }
+}
diff --git a/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3View.java b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3View.java
new file mode 100644
index 0000000000..8076bd5ca1
--- /dev/null
+++ b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/Sample3View.java
@@ -0,0 +1,29 @@
+package org.opencv.samples.tutorial3;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+class Sample3View extends SampleViewBase {
+
+    public Sample3View(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected Bitmap processFrame(byte[] data) {
+        int frameSize = getFrameWidth() * getFrameHeight();
+        int[] rgba = new int[frameSize];
+
+        FindFeatures(getFrameWidth(), getFrameHeight(), data, rgba);
+
+        Bitmap bmp = Bitmap.createBitmap(getFrameWidth(), getFrameHeight(), Bitmap.Config.ARGB_8888);
+        bmp.setPixels(rgba, 0/* offset */, getFrameWidth() /* stride */, 0, 0, getFrameWidth(), getFrameHeight());
+        return bmp;
+    }
+
+    public native void FindFeatures(int width, int height, byte yuv[], int[] rgba);
+
+    static {
+        System.loadLibrary("native_sample");
+    }
+}
diff --git a/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/SampleViewBase.java b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/SampleViewBase.java
new file mode 100644
index 0000000000..83af4ca72b
--- /dev/null
+++ b/samples/android/tutorial-3-native/src/org/opencv/samples/tutorial3/SampleViewBase.java
@@ -0,0 +1,125 @@
+package org.opencv.samples.tutorial3;
+
+import java.io.IOException;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.hardware.Camera;
+import android.hardware.Camera.PreviewCallback;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private Camera              mCamera;
+    private SurfaceHolder       mHolder;
+    private int                 mFrameWidth;
+    private int                 mFrameHeight;
+    private byte[]              mFrame;
+    private boolean             mThreadRun;
+
+    public SampleViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public int getFrameWidth() {
+        return mFrameWidth;
+    }
+
+    public int getFrameHeight() {
+        return mFrameHeight;
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        if (mCamera != null) {
+            Camera.Parameters params = mCamera.getParameters();
+            List<Camera.Size> sizes = params.getSupportedPreviewSizes();
+            mFrameWidth = width;
+            mFrameHeight = height;
+
+            // selecting optimal camera preview size
+            {
+                double minDiff = Double.MAX_VALUE;
+                for (Camera.Size size : sizes) {
+                    if (Math.abs(size.height - height) < minDiff) {
+                        mFrameWidth = size.width;
+                        mFrameHeight = size.height;
+                        minDiff = Math.abs(size.height - height);
+                    }
+                }
+            }
+
+            params.setPreviewSize(getFrameWidth(), getFrameHeight());
+            mCamera.setParameters(params);
+            try {
+				mCamera.setPreviewDisplay(null);
+			} catch (IOException e) {
+				Log.e(TAG, "mCamera.setPreviewDisplay fails: " + e);
+			}
+            mCamera.startPreview();
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = Camera.open();
+        mCamera.setPreviewCallback(new PreviewCallback() {
+            public void onPreviewFrame(byte[] data, Camera camera) {
+                synchronized (SampleViewBase.this) {
+                    mFrame = data;
+                    SampleViewBase.this.notify();
+                }
+            }
+        });
+        (new Thread(this)).start();
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        mThreadRun = false;
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.stopPreview();
+                mCamera.setPreviewCallback(null);
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(byte[] data);
+
+    public void run() {
+        mThreadRun = true;
+        Log.i(TAG, "Starting processing thread");
+        while (mThreadRun) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                try {
+                    this.wait();
+                    bmp = processFrame(mFrame);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - getFrameWidth()) / 2, (canvas.getHeight() - getFrameHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/samples/android/tutorial-4-mixed/.classpath b/samples/android/tutorial-4-mixed/.classpath
new file mode 100644
index 0000000000..a0a90f9b1c
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="src" path="OpenCV-2.3.1_src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/samples/android/tutorial-4-mixed/.project b/samples/android/tutorial-4-mixed/.project
new file mode 100644
index 0000000000..d5f3427685
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Tutorial 2 Advanced - 2. Mix Java+Native OpenCV</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<linkedResources>
+		<link>
+			<name>OpenCV-2.3.1_src</name>
+			<type>2</type>
+			<locationURI>_android_OpenCV_2_3_1_df28900a/src</locationURI>
+		</link>
+	</linkedResources>
+</projectDescription>
diff --git a/samples/android/tutorial-4-mixed/.settings/org.eclipse.jdt.core.prefs b/samples/android/tutorial-4-mixed/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000..d995784334
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,5 @@
+#Wed Jun 29 04:36:40 MSD 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/samples/android/tutorial-4-mixed/AndroidManifest.xml b/samples/android/tutorial-4-mixed/AndroidManifest.xml
new file mode 100644
index 0000000000..3201f7c041
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/AndroidManifest.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.opencv.samples.tutorial4"
+      android:versionCode="1"
+      android:versionName="1.0">
+
+    <supports-screens android:resizeable="true"
+                      android:smallScreens="true" 
+                      android:normalScreens="true" 
+                      android:largeScreens="true" 
+                      android:anyDensity="true" />
+
+    <application android:label="@string/app_name" android:icon="@drawable/icon">
+        <activity android:name="Sample4Mixed"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:configChanges="keyboardHidden|orientation">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    
+    <uses-sdk android:minSdkVersion="8" />
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+
+</manifest> 
diff --git a/samples/android/tutorial-4-mixed/default.properties b/samples/android/tutorial-4-mixed/default.properties
new file mode 100644
index 0000000000..fb3ea1f7b3
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/default.properties
@@ -0,0 +1,3 @@
+android.library.reference.1=../../../android/build
+# Project target.
+target=android-8
diff --git a/samples/android/tutorial-4-mixed/jni/Android.mk b/samples/android/tutorial-4-mixed/jni/Android.mk
new file mode 100644
index 0000000000..cb230ac368
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/jni/Android.mk
@@ -0,0 +1,18 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+OPENCV_CAMERA_MODULES:=off
+include ../includeOpenCV.mk
+ifeq ("$(wildcard $(OPENCV_MK_PATH))","")
+	#try to load OpenCV.mk from default install location
+	include $(TOOLCHAIN_PREBUILT_ROOT)/user/share/OpenCV/OpenCV.mk
+else
+	include $(OPENCV_MK_PATH)
+endif
+
+LOCAL_MODULE    := mixed_sample
+LOCAL_SRC_FILES := jni_part.cpp
+LOCAL_LDLIBS +=  -llog -ldl
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/samples/android/tutorial-4-mixed/jni/Application.mk b/samples/android/tutorial-4-mixed/jni/Application.mk
new file mode 100644
index 0000000000..c7de9c761b
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/jni/Application.mk
@@ -0,0 +1,3 @@
+APP_STL := gnustl_static
+APP_CPPFLAGS := -frtti -fexceptions
+APP_ABI := armeabi-v7a
diff --git a/samples/android/tutorial-4-mixed/jni/jni_part.cpp b/samples/android/tutorial-4-mixed/jni/jni_part.cpp
new file mode 100644
index 0000000000..dd989e6524
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/jni/jni_part.cpp
@@ -0,0 +1,23 @@
+#include <jni.h>
+#include <opencv2/core/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/features2d/features2d.hpp>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+extern "C" {
+JNIEXPORT void JNICALL Java_org_opencv_samples_tutorial4_Sample4View_FindFeatures(JNIEnv* env, jobject thiz, jlong addrGray, jlong addrRgba)
+{
+    Mat* pMatGr=(Mat*)addrGray;
+    Mat* pMatRgb=(Mat*)addrRgba;
+    vector<KeyPoint> v;
+
+    FastFeatureDetector detector(50);
+    detector.detect(*pMatGr, v);
+    for( size_t i = 0; i < v.size(); i++ )
+        circle(*pMatRgb, Point(v[i].pt.x, v[i].pt.y), 10, Scalar(255,0,0,255));
+}
+
+}
diff --git a/samples/android/tutorial-4-mixed/res/drawable/icon.png b/samples/android/tutorial-4-mixed/res/drawable/icon.png
new file mode 100644
index 0000000000..4e828bafd8
Binary files /dev/null and b/samples/android/tutorial-4-mixed/res/drawable/icon.png differ
diff --git a/samples/android/tutorial-4-mixed/res/values/strings.xml b/samples/android/tutorial-4-mixed/res/values/strings.xml
new file mode 100644
index 0000000000..428138a741
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">Tutorial 2 Advanced - 2. Mix Java+Native OpenCV</string>
+</resources>
diff --git a/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4Mixed.java b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4Mixed.java
new file mode 100644
index 0000000000..0c5eda42b9
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4Mixed.java
@@ -0,0 +1,59 @@
+package org.opencv.samples.tutorial4;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+
+public class Sample4Mixed extends Activity {
+    private static final String TAG                = "Sample::Activity";
+
+    public static final int     VIEW_MODE_RGBA     = 0;
+    public static final int     VIEW_MODE_GRAY     = 1;
+    public static final int     VIEW_MODE_CANNY    = 2;
+    public static final int     VIEW_MODE_FEATURES = 5;
+
+    private MenuItem            mItemPreviewRGBA;
+    private MenuItem            mItemPreviewGray;
+    private MenuItem            mItemPreviewCanny;
+    private MenuItem            mItemPreviewFeatures;
+
+    public static int           viewMode           = VIEW_MODE_RGBA;
+
+    public Sample4Mixed() {
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    /** Called when the activity is first created. */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Log.i(TAG, "onCreate");
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(new Sample4View(this));
+    }
+
+    public boolean onCreateOptionsMenu(Menu menu) {
+        Log.i(TAG, "onCreateOptionsMenu");
+        mItemPreviewRGBA = menu.add("Preview RGBA");
+        mItemPreviewGray = menu.add("Preview GRAY");
+        mItemPreviewCanny = menu.add("Canny");
+        mItemPreviewFeatures = menu.add("Find features");
+        return true;
+    }
+
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Log.i(TAG, "Menu Item selected " + item);
+        if (item == mItemPreviewRGBA)
+            viewMode = VIEW_MODE_RGBA;
+        else if (item == mItemPreviewGray)
+            viewMode = VIEW_MODE_GRAY;
+        else if (item == mItemPreviewCanny)
+            viewMode = VIEW_MODE_CANNY;
+        else if (item == mItemPreviewFeatures)
+            viewMode = VIEW_MODE_FEATURES;
+        return true;
+    }
+}
diff --git a/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4View.java b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4View.java
new file mode 100644
index 0000000000..94f421fd90
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/Sample4View.java
@@ -0,0 +1,93 @@
+package org.opencv.samples.tutorial4;
+
+import org.opencv.android.Utils;
+import org.opencv.core.Mat;
+import org.opencv.core.CvType;
+import org.opencv.imgproc.Imgproc;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.SurfaceHolder;
+
+class Sample4View extends SampleViewBase {
+    private Mat mYuv;
+    private Mat mRgba;
+    private Mat mGraySubmat;
+    private Mat mIntermediateMat;
+
+    public Sample4View(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        super.surfaceChanged(_holder, format, width, height);
+
+        synchronized (this) {
+            // initialize Mats before usage
+            mYuv = new Mat(getFrameHeight() + getFrameHeight() / 2, getFrameWidth(), CvType.CV_8UC1);
+            mGraySubmat = mYuv.submat(0, getFrameHeight(), 0, getFrameWidth());
+
+            mRgba = new Mat();
+            mIntermediateMat = new Mat();
+        }
+    }
+
+    @Override
+    protected Bitmap processFrame(byte[] data) {
+        mYuv.put(0, 0, data);
+
+        switch (Sample4Mixed.viewMode) {
+        case Sample4Mixed.VIEW_MODE_GRAY:
+            Imgproc.cvtColor(mGraySubmat, mRgba, Imgproc.COLOR_GRAY2RGBA, 4);
+            break;
+        case Sample4Mixed.VIEW_MODE_RGBA:
+            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
+            break;
+        case Sample4Mixed.VIEW_MODE_CANNY:
+            Imgproc.Canny(mGraySubmat, mIntermediateMat, 80, 100);
+            Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);
+            break;
+        case Sample4Mixed.VIEW_MODE_FEATURES:
+            Imgproc.cvtColor(mYuv, mRgba, Imgproc.COLOR_YUV420sp2RGB, 4);
+            FindFeatures(mGraySubmat.getNativeObjAddr(), mRgba.getNativeObjAddr());
+            break;
+        }
+
+        Bitmap bmp = Bitmap.createBitmap(getFrameWidth(), getFrameHeight(), Bitmap.Config.ARGB_8888);
+
+        if (Utils.matToBitmap(mRgba, bmp))
+            return bmp;
+
+        bmp.recycle();
+        return null;
+    }
+
+    @Override
+    public void run() {
+        super.run();
+
+        synchronized (this) {
+            // Explicitly deallocate Mats
+            if (mYuv != null)
+                mYuv.release();
+            if (mRgba != null)
+                mRgba.release();
+            if (mGraySubmat != null)
+                mGraySubmat.release();
+            if (mIntermediateMat != null)
+                mIntermediateMat.release();
+
+            mYuv = null;
+            mRgba = null;
+            mGraySubmat = null;
+            mIntermediateMat = null;
+        }
+    }
+
+    public native void FindFeatures(long matAddrGr, long matAddrRgba);
+
+    static {
+        System.loadLibrary("mixed_sample");
+    }
+}
diff --git a/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/SampleViewBase.java b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/SampleViewBase.java
new file mode 100644
index 0000000000..a0d474c549
--- /dev/null
+++ b/samples/android/tutorial-4-mixed/src/org/opencv/samples/tutorial4/SampleViewBase.java
@@ -0,0 +1,125 @@
+package org.opencv.samples.tutorial4;
+
+import java.io.IOException;
+import java.util.List;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.hardware.Camera;
+import android.hardware.Camera.PreviewCallback;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public abstract class SampleViewBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
+    private static final String TAG = "Sample::SurfaceView";
+
+    private Camera              mCamera;
+    private SurfaceHolder       mHolder;
+    private int                 mFrameWidth;
+    private int                 mFrameHeight;
+    private byte[]              mFrame;
+    private boolean             mThreadRun;
+
+    public SampleViewBase(Context context) {
+        super(context);
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+        Log.i(TAG, "Instantiated new " + this.getClass());
+    }
+
+    public int getFrameWidth() {
+        return mFrameWidth;
+    }
+
+    public int getFrameHeight() {
+        return mFrameHeight;
+    }
+
+    public void surfaceChanged(SurfaceHolder _holder, int format, int width, int height) {
+        Log.i(TAG, "surfaceCreated");
+        if (mCamera != null) {
+            Camera.Parameters params = mCamera.getParameters();
+            List<Camera.Size> sizes = params.getSupportedPreviewSizes();
+            mFrameWidth = width;
+            mFrameHeight = height;
+
+            // selecting optimal camera preview size
+            {
+                double minDiff = Double.MAX_VALUE;
+                for (Camera.Size size : sizes) {
+                    if (Math.abs(size.height - height) < minDiff) {
+                        mFrameWidth = size.width;
+                        mFrameHeight = size.height;
+                        minDiff = Math.abs(size.height - height);
+                    }
+                }
+            }
+
+            params.setPreviewSize(getFrameWidth(), getFrameHeight());
+            mCamera.setParameters(params);
+            try {
+				mCamera.setPreviewDisplay(null);
+			} catch (IOException e) {
+				Log.e(TAG, "mCamera.setPreviewDisplay fails: " + e);
+			}
+            mCamera.startPreview();
+        }
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceCreated");
+        mCamera = Camera.open();
+        mCamera.setPreviewCallback(new PreviewCallback() {
+            public void onPreviewFrame(byte[] data, Camera camera) {
+                synchronized (SampleViewBase.this) {
+                    mFrame = data;
+                    SampleViewBase.this.notify();
+                }
+            }
+        });
+        (new Thread(this)).start();
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        Log.i(TAG, "surfaceDestroyed");
+        mThreadRun = false;
+        if (mCamera != null) {
+            synchronized (this) {
+                mCamera.stopPreview();
+                mCamera.setPreviewCallback(null);
+                mCamera.release();
+                mCamera = null;
+            }
+        }
+    }
+
+    protected abstract Bitmap processFrame(byte[] data);
+
+    public void run() {
+        mThreadRun = true;
+        Log.i(TAG, "Starting processing thread");
+        while (mThreadRun) {
+            Bitmap bmp = null;
+
+            synchronized (this) {
+                try {
+                    this.wait();
+                    bmp = processFrame(mFrame);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            if (bmp != null) {
+                Canvas canvas = mHolder.lockCanvas();
+                if (canvas != null) {
+                    canvas.drawBitmap(bmp, (canvas.getWidth() - getFrameWidth()) / 2, (canvas.getHeight() - getFrameHeight()) / 2, null);
+                    mHolder.unlockCanvasAndPost(canvas);
+                }
+                bmp.recycle();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/samples/c/bgfg_codebook.cpp b/samples/c/bgfg_codebook.cpp
index 99960581d5..83c82d4252 100644
--- a/samples/c/bgfg_codebook.cpp
+++ b/samples/c/bgfg_codebook.cpp
@@ -20,25 +20,29 @@
      Or: http://oreilly.com/catalog/9780596516130/
      ISBN-10: 0596516134 or: ISBN-13: 978-0596516130    
 ************************************************** */
+#include "opencv2/core/core.hpp"
+#include "opencv2/video/background_segm.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/highgui/highgui.hpp"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 
-#include "opencv2/video/background_segm.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/highgui/highgui.hpp"
+using namespace std;
+using namespace cv;
 
 //VARIABLES for CODEBOOK METHOD:
 CvBGCodeBookModel* model = 0;
 const int NCHANNELS = 3;
 bool ch[NCHANNELS]={true,true,true}; // This sets what channels should be adjusted for background bounds
 
-void help(void)
+void help()
 {
     printf("\nLearn background and find foreground using simple average and average difference learning method:\n"
     		"Originally from the book: Learning OpenCV by O'Reilly press\n"
-        "\nUSAGE:\nbgfg_codebook [--nframes=300] [movie filename, else from camera]\n"
+        "\nUSAGE:\n"
+        "   bgfg_codebook [--nframes(-nf)=300] [--movie_filename(-mf)=tree.avi] [--camera(-c), use camera or not]\n"
         "***Keep the focus on the video windows, NOT the consol***\n\n"
         "INTERACTIVE PARAMETERS:\n"
         "\tESC,q,Q  - quit the program\n"
@@ -65,15 +69,25 @@ void help(void)
 //USAGE:  ch9_background startFrameCollection# endFrameCollection# [movie filename, else from camera]
 //If from AVI, then optionally add HighAvg, LowAvg, HighCB_Y LowCB_Y HighCB_U LowCB_U HighCB_V LowCB_V
 //
-int main(int argc, char** argv)
+const char *keys =
 {
-    const char* filename = 0;
+    "{nf|nframes   |300        |frames number}"
+    "{c |camera    |false      |use the camera or not}"
+    "{mf|movie_file|tree.avi   |used movie video file}"
+};
+int main(int argc, const char** argv)
+{
+    help();
+
+    CommandLineParser parser(argc, argv, keys);
+    int nframesToLearnBG = parser.get<int>("nf");
+    bool useCamera = parser.get<bool>("c");
+    string filename = parser.get<string>("mf");
     IplImage* rawImage = 0, *yuvImage = 0; //yuvImage is for codebook method
     IplImage *ImaskCodeBook = 0,*ImaskCodeBookCC = 0;
     CvCapture* capture = 0;
 
     int c, n, nframes = 0;
-    int nframesToLearnBG = 300;
 
     model = cvCreateBGCodeBookModel();
     
@@ -87,30 +101,15 @@ int main(int argc, char** argv)
     bool pause = false;
     bool singlestep = false;
 
-    for( n = 1; n < argc; n++ )
-    {
-        static const char* nframesOpt = "--nframes=";
-        if( strncmp(argv[n], nframesOpt, strlen(nframesOpt))==0 )
-        {
-            if( sscanf(argv[n] + strlen(nframesOpt), "%d", &nframesToLearnBG) == 0 )
-            {
-                help();
-                return -1;
-            }
-        }
-        else
-            filename = argv[n];
-    }
-
-    if( !filename )
+    if( useCamera )
     {
         printf("Capture from camera\n");
         capture = cvCaptureFromCAM( 0 );
     }
     else
     {
-        printf("Capture from file %s\n",filename);
-        capture = cvCreateFileCapture( filename );
+        printf("Capture from file %s\n",filename.c_str());
+        capture = cvCreateFileCapture( filename.c_str() );
     }
 
     if( !capture )
diff --git a/samples/c/find_obj.cpp b/samples/c/find_obj.cpp
index cd88b8a4b6..693e16b364 100644
--- a/samples/c/find_obj.cpp
+++ b/samples/c/find_obj.cpp
@@ -12,6 +12,7 @@
 
 #include <iostream>
 #include <vector>
+#include <stdio.h>
 
 using namespace std;
 void help()
diff --git a/samples/c/find_obj_ferns.cpp b/samples/c/find_obj_ferns.cpp
index e944acb0fa..efb6670525 100644
--- a/samples/c/find_obj_ferns.cpp
+++ b/samples/c/find_obj_ferns.cpp
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <iostream>
 #include <vector>
+#include <stdio.h>
 
 using namespace cv;
 void help()
diff --git a/samples/c/mser_sample.cpp b/samples/c/mser_sample.cpp
index 94519d63d4..9aa0e33461 100644
--- a/samples/c/mser_sample.cpp
+++ b/samples/c/mser_sample.cpp
@@ -6,6 +6,7 @@
 #include "opencv2/features2d/features2d.hpp"
 #include "opencv2/imgproc/imgproc_c.h"
 
+#include <stdio.h>
 
 void help()
 {
diff --git a/samples/c/one_way_sample.cpp b/samples/c/one_way_sample.cpp
index 476be225b9..8907cbfde4 100644
--- a/samples/c/one_way_sample.cpp
+++ b/samples/c/one_way_sample.cpp
@@ -13,6 +13,8 @@
 #include "opencv2/imgproc/imgproc_c.h"
 
 #include <string>
+#include <stdio.h>
+
 void help()
 {
 	printf("\nThis program demonstrates the one way interest point descriptor found in features2d.hpp\n"
diff --git a/samples/cpp/bgfg_segm.cpp b/samples/cpp/bgfg_segm.cpp
index c93f44c5ba..f41716532c 100644
--- a/samples/cpp/bgfg_segm.cpp
+++ b/samples/cpp/bgfg_segm.cpp
@@ -1,7 +1,9 @@
+#include "opencv2/core/core.hpp"
 #include "opencv2/video/background_segm.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include <stdio.h>
 
+using namespace std;
 using namespace cv;
 
 void help()
@@ -9,22 +11,33 @@ void help()
  printf("\nDo background segmentation, especially demonstrating the use of cvUpdateBGStatModel().\n"
 "Learns the background at the start and then segments.\n"
 "Learning is togged by the space key. Will read from file or camera\n"
-"Call:\n"
-"./  bgfg_segm [file name -- if no name, read from camera]\n\n");
+"Usage: \n"
+"			./bgfg_segm [--camera]=<use camera, if this key is present>, [--file_name]=<path to movie file> \n\n");
 }
 
-//this is a sample for foreground detection functions
-int main(int argc, char** argv)
+const char* keys = 
 {
+	"{c |camera   |false    | use camera or not}"
+	"{fn|file_name|tree.avi | movie file             }"
+};
+
+//this is a sample for foreground detection functions
+int main(int argc, const char** argv)
+{
+	help();
+
+	CommandLineParser parser(argc, argv, keys);
+	bool useCamera = parser.get<bool>("camera");
+	string file = parser.get<string>("file_name");
     VideoCapture cap;
     bool update_bg_model = true;
 
-    if( argc < 2 )
+    if( useCamera )
         cap.open(0);
     else
-        cap.open(argv[1]);
-    help();
-    
+		cap.open(file.c_str());
+	parser.printParams();
+
     if( !cap.isOpened() )
     {
         printf("can not open camera or video file\n");
diff --git a/samples/cpp/brief_match_test.cpp b/samples/cpp/brief_match_test.cpp
index 5c491dac2c..c70a96630b 100644
--- a/samples/cpp/brief_match_test.cpp
+++ b/samples/cpp/brief_match_test.cpp
@@ -4,6 +4,7 @@
  *  Created on: Oct 17, 2010
  *      Author: ethan
  */
+#include "opencv2/core/core.hpp"
 #include "opencv2/calib3d/calib3d.hpp"
 #include "opencv2/features2d/features2d.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
@@ -12,20 +13,7 @@
 #include <iostream>
 
 using namespace cv;
-
-using std::cout;
-using std::cerr;
-using std::endl;
-using std::vector;
-
-void help(char **av)
-{
-	   cerr << "usage: " << av[0] << " im1.jpg im2.jpg"
-			   << "\n"
-			   << "This program shows how to use BRIEF descriptor to match points in features2d\n"
-			   << "It takes in two images, finds keypoints and matches them displaying matches and final homography warped results\n"
-			   << endl;
-}
+using namespace std;
 
 //Copy (x,y) location of descriptor matches found from KeyPoint data structures into Point2f vectors
 void matches2points(const vector<DMatch>& matches, const vector<KeyPoint>& kpts_train,
@@ -53,25 +41,38 @@ double match(const vector<KeyPoint>& /*kpts_train*/, const vector<KeyPoint>& /*k
   return ((double)getTickCount() - t) / getTickFrequency();
 }
 
-
-
-int main(int ac, char ** av)
+void help()
 {
-  if (ac != 3)
-  {
-	help(av);
-    return 1;
-  }
-  string im1_name, im2_name;
-  im1_name = av[1];
-  im2_name = av[2];
+       cout << "This program shows how to use BRIEF descriptor to match points in features2d" << endl <<
+               "It takes in two images, finds keypoints and matches them displaying matches and final homography warped results" << endl <<
+                "Usage: " << endl <<
+                    "image1 image2 " << endl <<
+                "Example: " << endl <<
+                    "box.png box_in_scene.png " << endl;
+}
+
+const char* keys = 
+{
+	"{1|  |box.png               |the first image}"
+	"{2|  |box_in_scene.png|the second image}"
+};
+
+int main(int argc, const char ** argv)
+{
+
+  help();
+  CommandLineParser parser(argc, argv, keys);
+  string im1_name = parser.get<string>("1");
+  string im2_name = parser.get<string>("2");
 
   Mat im1 = imread(im1_name, CV_LOAD_IMAGE_GRAYSCALE);
   Mat im2 = imread(im2_name, CV_LOAD_IMAGE_GRAYSCALE);
 
   if (im1.empty() || im2.empty())
   {
-    cerr << "could not open one of the images..." << endl;
+    cout << "could not open one of the images..." << endl;
+    cout << "the cmd parameters have next current value: " << endl;
+	parser.printParams();
     return 1;
   }
 
diff --git a/samples/cpp/build3dmodel.cpp b/samples/cpp/build3dmodel.cpp
index 5ef25f4b7b..081c9db336 100644
--- a/samples/cpp/build3dmodel.cpp
+++ b/samples/cpp/build3dmodel.cpp
@@ -251,7 +251,7 @@ static void findConstrainedCorrespondences(const Mat& _F,
                 if( dist < threshold )
                     break;
             }
-            if( i1 == keypoints1.size() )
+            if( i1 == (int)keypoints1.size() )
                 matches.push_back(Vec2i(i,bestIdx1));
         }
     }
diff --git a/samples/cpp/calibration_artificial.cpp b/samples/cpp/calibration_artificial.cpp
index 2f683ffb70..25149c3fda 100644
--- a/samples/cpp/calibration_artificial.cpp
+++ b/samples/cpp/calibration_artificial.cpp
@@ -1,14 +1,16 @@
-#include <iostream>
-#include <vector>
-#include <algorithm>
-#include <iterator>
-
 #include "opencv2/calib3d/calib3d.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/highgui/highgui.hpp"
 
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include <stdio.h>
+
 using namespace cv;
 using namespace std;
+
 void help()
 {
     printf( "\nThis code generates an artificial camera and artificial chessboard images,\n"
@@ -133,8 +135,8 @@ int main()
     cout << "Original camera matrix:\n" << camMat << endl;
     cout << "Original distCoeffs:\n" << distCoeffs << endl;
     cout << "==================================" << endl;
-    cout << "Estiamted camera matrix:\n" << (Mat_<double>&)camMat_est << endl;
-    cout << "Estiamted distCoeffs:\n" << (Mat_<double>&)distCoeffs_est << endl;
+    cout << "Estimated camera matrix:\n" << (Mat_<double>&)camMat_est << endl;
+    cout << "Estimated distCoeffs:\n" << (Mat_<double>&)distCoeffs_est << endl;
         
     return 0;
 }
diff --git a/samples/cpp/camshiftdemo.cpp b/samples/cpp/camshiftdemo.cpp
index fb518fdbd4..921ac9ed3f 100644
--- a/samples/cpp/camshiftdemo.cpp
+++ b/samples/cpp/camshiftdemo.cpp
@@ -8,24 +8,6 @@
 using namespace cv;
 using namespace std;
 
-void help()
-{
-	cout << "\nThis is a demo that shows mean-shift based tracking\n"
-		 <<   "You select a color objects such as your face and it tracks it.\n"
-		 <<   "This reads from video camera (0 by default, or the camera number the user enters\n"
-		 << "Call:\n"
-		 << "\n./camshiftdemo [camera number]"
-		 << "\n" << endl;
-
-	cout << "\n\nHot keys: \n"
-        "\tESC - quit the program\n"
-        "\tc - stop the tracking\n"
-        "\tb - switch to/from backprojection view\n"
-        "\th - show/hide object histogram\n"
-        "\tp - pause video\n"
-        "To initialize tracking, select the object with mouse\n" << endl;
-}
-
 Mat image;
 
 bool backprojMode = false;
@@ -63,31 +45,52 @@ void onMouse( int event, int x, int y, int, void* )
     }
 }
 
-
-
-int main( int argc, char** argv )
+void help()
 {
+    cout << "\nThis is a demo that shows mean-shift based tracking\n"
+			"You select a color objects such as your face and it tracks it.\n"
+			"This reads from video camera (0 by default, or the camera number the user enters\n"
+			"Usage: \n"
+            "	./camshiftdemo [camera number]\n";
+
+    cout << "\n\nHot keys: \n"
+			"\tESC - quit the program\n"
+			"\tc - stop the tracking\n"
+			"\tb - switch to/from backprojection view\n"
+			"\th - show/hide object histogram\n"
+			"\tp - pause video\n"
+            "To initialize tracking, select the object with mouse\n";
+}
+
+const char* keys = 
+{
+	"{1|  | 0 | camera number}"
+};
+
+int main( int argc, const char** argv )
+{
+	help();
+
     VideoCapture cap;
     Rect trackWindow;
     RotatedRect trackBox;
     int hsize = 16;
     float hranges[] = {0,180};
     const float* phranges = hranges;
-
-    if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])))
-        cap.open(argc == 2 ? argv[1][0] - '0' : 0);
-    else if( argc == 2 )
-        cap.open(argv[1]);
+	CommandLineParser parser(argc, argv, keys);
+	int camNum = parser.get<int>("1");     
+	
+	cap.open(camNum);
 
     if( !cap.isOpened() )
     {
     	help();
         cout << "***Could not initialize capturing...***\n";
-        return 0;
+        cout << "Current parameter's value: \n";
+		parser.printParams();
+        return -1;
     }
 
-    help();
-
     namedWindow( "Histogram", 0 );
     namedWindow( "CamShift Demo", 0 );
     setMouseCallback( "CamShift Demo", onMouse, 0 );
diff --git a/samples/cpp/chamfer.cpp b/samples/cpp/chamfer.cpp
index 9e4524a6bc..2c03d3dc37 100644
--- a/samples/cpp/chamfer.cpp
+++ b/samples/cpp/chamfer.cpp
@@ -9,29 +9,38 @@ using namespace std;
 
 void help()
 {
-    cout <<
-        "\nThis program demonstrates Chamfer matching -- computing a distance between an \n"
-        "edge template and a query edge image.\n"
-        "Usage:\n"
-        "./chamfer <image edge map> <template edge map>,"
-        " By default the inputs are logo_in_clutter.png logo.png\n" << endl;
-
-    return;
+ 
+   cout << "\nThis program demonstrates Chamfer matching -- computing a distance between an \n"
+            "edge template and a query edge image.\n"
+            "Usage: \n"
+            "./chamfer <image edge map> <template edge map>,"
+            " By default the inputs are logo_in_clutter.png logo.png\n";
 }
 
-
-int main( int argc, char** argv )
+const char* keys = 
 {
-    if( argc != 3 )
-    {
-        help();
-        return 0;
-    }
+	"{1| |logo_in_clutter.png|image edge map    }"
+	"{2| |logo.png               |template edge map}"
+};
 
-    Mat img = imread(argc == 3 ? argv[1] : "logo_in_clutter.png", 0);
+int main( int argc, const char** argv )
+{
+
+	help();
+	CommandLineParser parser(argc, argv, keys);
+
+	string image = parser.get<string>("1");
+	string templ = parser.get<string>("2");
+	Mat img = imread(image.c_str(), 0);
+	Mat tpl = imread(templ.c_str(), 0);
+
+	if (img.empty() || tpl.empty())
+    {
+        cout << "Could not read image file " << image << " or " << templ << "." << endl;
+        return -1;
+    }
     Mat cimg;
     cvtColor(img, cimg, CV_GRAY2BGR);
-    Mat tpl = imread(argc == 3 ? argv[2] : "logo.png", 0);
 
     // if the image and the template are not edge maps but normal grayscale images,
     // you might want to uncomment the lines below to produce the maps. You can also
@@ -45,8 +54,8 @@ int main( int argc, char** argv )
     int best = chamerMatching( img, tpl, results, costs );
     if( best < 0 )
     {
-        cout << "matching not found\n";
-        return 0;
+        cout << "matching not found" << endl;
+        return -1;
     }
 
     size_t i, n = results[best].size();
diff --git a/samples/cpp/connected_components.cpp b/samples/cpp/connected_components.cpp
index 01bff9c0a6..ce9a41ef3d 100644
--- a/samples/cpp/connected_components.cpp
+++ b/samples/cpp/connected_components.cpp
@@ -8,19 +8,6 @@ using namespace std;
 Mat img;
 int threshval = 100;
 
-void help()
-{
-	cout <<
-		   "\n This program demonstrates connected components and use of the trackbar\n"
-		<< "\n"
-		<< "Usage: ./connected_components <image>\n"
-		<< "\n"
-		<< "The image is converted to grayscale and displayed, another image has a trackbar\n"
-		<< "that controls thresholding and thereby the extracted contours which are drawn in color\n"
-		<< endl;
-}
-
-
 void on_trackbar(int, void*)
 {
 	Mat bw = threshval < 128 ? (img < threshval) : (img > threshval);
@@ -47,18 +34,34 @@ void on_trackbar(int, void*)
 	imshow( "Connected Components", dst );
 }
 
-int main( int argc, char** argv )
+void help()
 {
-    // the first command line parameter
-	if(argc != 2)
+    cout << "\n This program demonstrates connected components and use of the trackbar\n"
+			 "Usage: \n"
+			 "	./connected_components <image(stuff.jpg as default)>\n"
+			 "The image is converted to grayscale and displayed, another image has a trackbar\n"
+             "that controls thresholding and thereby the extracted contours which are drawn in color\n";
+}
+
+const char* keys = 
+{
+	"{1| |stuff.jpg|image for converting to a grayscale}"
+};
+
+int main( int argc, const char** argv )
+{
+	help();
+	CommandLineParser parser(argc, argv, keys);
+	string inputImage = parser.get<string>("1");
+	img = imread(inputImage.c_str(), 0);
+
+	if(img.empty())
 	{
-		help();
+        cout << "Could not read input image file: " << inputImage << endl;
 		return -1;
 	}
-    if( !(img=imread(argc == 2 ? argv[1] : "stuff.jpg", 0)).data) //The ending 0 in imread converts the image to grayscale.
-        return -1;
 
-    namedWindow( "Image", 1 );
+	namedWindow( "Image", 1 );
     imshow( "Image", img );
 
 	namedWindow( "Connected Components", 1 );
diff --git a/samples/cpp/delaunay2.cpp b/samples/cpp/delaunay2.cpp
new file mode 100644
index 0000000000..87bc5ebd96
--- /dev/null
+++ b/samples/cpp/delaunay2.cpp
@@ -0,0 +1,150 @@
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+static void help()
+{
+	cout << "\nThis program demostrates iterative construction of\n"
+           "delaunay triangulation and voronoi tesselation.\n"
+           "It draws a random set of points in an image and then delaunay triangulates them.\n"
+           "Usage: \n"
+           "./delaunay \n"
+           "\nThis program builds the traingulation interactively, you may stop this process by\n"
+           "hitting any key.\n";
+}
+
+static void draw_subdiv_point( Mat& img, Point2f fp, Scalar color )
+{
+    circle( img, fp, 3, color, CV_FILLED, 8, 0 );
+}
+
+static void draw_subdiv( Mat& img, Subdiv2D& subdiv, Scalar delaunay_color )
+{
+#if 1
+    vector<Vec6f> triangleList;
+    subdiv.getTriangleList(triangleList);
+    vector<Point> pt(3);
+    
+    for( size_t i = 0; i < triangleList.size(); i++ )
+    {
+        Vec6f t = triangleList[i];
+        pt[0] = Point(cvRound(t[0]), cvRound(t[1]));
+        pt[1] = Point(cvRound(t[2]), cvRound(t[3]));
+        pt[2] = Point(cvRound(t[4]), cvRound(t[5]));
+        line(img, pt[0], pt[1], delaunay_color, 1, CV_AA, 0);
+        line(img, pt[1], pt[2], delaunay_color, 1, CV_AA, 0);
+        line(img, pt[2], pt[0], delaunay_color, 1, CV_AA, 0);
+    }
+#else
+    vector<Vec4f> edgeList;
+    subdiv.getEdgeList(edgeList);
+    for( size_t i = 0; i < edgeList.size(); i++ )
+    {
+        Vec4f e = edgeList[i];
+        Point pt0 = Point(cvRound(e[0]), cvRound(e[1]));
+        Point pt1 = Point(cvRound(e[2]), cvRound(e[3]));
+        line(img, pt0, pt1, delaunay_color, 1, CV_AA, 0);
+    }
+#endif
+}
+
+static void locate_point( Mat& img, Subdiv2D& subdiv, Point2f fp, Scalar active_color )
+{
+    int e0=0, vertex=0;
+    
+    CvSubdiv2DEdge e00;
+    
+    subdiv.locate(fp, e0, vertex);
+    
+    if( e0 > 0 )
+    {
+        int e = e0;
+        do
+        {
+            Point2f org, dst;
+            if( subdiv.edgeOrg(e, &org) > 0 && subdiv.edgeDst(e, &dst) > 0 )
+                line( img, org, dst, active_color, 3, CV_AA, 0 );
+                
+            e = subdiv.getEdge(e, Subdiv2D::NEXT_AROUND_LEFT);
+        }
+        while( e != e0 );
+    }
+    
+    draw_subdiv_point( img, fp, active_color );
+}
+
+
+void paint_voronoi( Mat& img, Subdiv2D& subdiv )
+{
+    vector<vector<Point2f> > facets;
+    vector<Point2f> centers;
+    subdiv.getVoronoiFacetList(vector<int>(), facets, centers);
+    
+    vector<Point> ifacet;
+    vector<vector<Point> > ifacets(1);
+    
+    for( size_t i = 0; i < facets.size(); i++ )
+    {
+        ifacet.resize(facets[i].size());
+        for( size_t j = 0; j < facets[i].size(); j++ )
+            ifacet[j] = facets[i][j];
+    
+        Scalar color;
+        color[0] = rand() & 255;
+        color[1] = rand() & 255;
+        color[2] = rand() & 255;
+        fillConvexPoly(img, ifacet, color, 8, 0);
+        
+        ifacets[0] = ifacet;
+        polylines(img, ifacets, true, Scalar(), 1, CV_AA, 0);
+        circle(img, centers[i], 3, Scalar(), -1, CV_AA, 0);
+    }
+}
+
+
+int main( int, char** )
+{
+    help();
+    
+    Scalar active_facet_color(0, 0, 255), delaunay_color(255,255,255);
+    Rect rect(0, 0, 600, 600);
+    
+    Subdiv2D subdiv(rect);
+    Mat img(rect.size(), CV_8UC3);
+    
+    img = Scalar::all(0);
+    string win = "Delaunay Demo";
+    imshow(win, img);
+    
+    for( int i = 0; i < 200; i++ )
+    {
+        Point2f fp( (float)(rand()%(rect.width-10)+5),
+                    (float)(rand()%(rect.height-10)+5));
+        
+        locate_point( img, subdiv, fp, active_facet_color );
+        imshow( win, img );
+        
+        if( waitKey( 100 ) >= 0 )
+            break;
+        
+        subdiv.insert(fp);
+        
+        img = Scalar::all(0);
+        draw_subdiv( img, subdiv, delaunay_color );
+        imshow( win, img );
+        
+        if( waitKey( 100 ) >= 0 )
+            break;
+    }
+    
+    img = Scalar::all(0);
+    paint_voronoi( img, subdiv );
+    imshow( win, img );
+        
+    waitKey(0);
+    
+    return 0;
+}
diff --git a/samples/cpp/demhist.cpp b/samples/cpp/demhist.cpp
index cf48c25e3a..d71ea5c858 100644
--- a/samples/cpp/demhist.cpp
+++ b/samples/cpp/demhist.cpp
@@ -56,22 +56,30 @@ void updateBrightnessContrast( int /*arg*/, void* )
 }
 void help()
 {
-	cout << "\nThis program demonstrates the use of calcHist() -- histogram creation.\n"
-			"Call:\n"
-			"demhist [image_name -- Defaults to baboon.jpg]\n" << endl;
+	std::cout << "\nThis program demonstrates the use of calcHist() -- histogram creation.\n"
+	          << "Usage: \n" << "demhist [image_name -- Defaults to baboon.jpg]" << std::endl;
 }
 
-int main( int argc, char** argv )
+const char* keys = 
 {
-    // Load the source image. HighGUI use.
-    image = imread( argc == 2 ? argv[1] : "baboon.jpg", 0 );
+	"{1| |baboon.jpg|input image file}"
+};
+
+int main( int argc, const char** argv )
+{
+	help();
+
+	CommandLineParser parser(argc, argv, keys);
+	string inputImage = parser.get<string>("1");
+
+	// Load the source image. HighGUI use.
+	image = imread( inputImage, 0 );
+	if(image.empty())
+	{
+		std::cerr << "Cannot read image file: " << inputImage << std::endl;
+		return -1;
+	}
 
-    if( image.empty() )
-    {
-        help();
-        return -1;
-    }
-    help();
     namedWindow("image", 0);
     namedWindow("histogram", 0);
 
diff --git a/samples/cpp/dft.cpp b/samples/cpp/dft.cpp
index 7d110ae04d..ee1d9b1656 100644
--- a/samples/cpp/dft.cpp
+++ b/samples/cpp/dft.cpp
@@ -2,31 +2,37 @@
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/highgui/highgui.hpp"
 
-#include <iostream>
+#include <stdio.h>
+
 using namespace cv;
 using namespace std;
 
 void help()
 {
-	cout << "\nThis program demonstrated the use of the discrete Fourier transform (dft)\n"
-			"The dft of an image is taken and it's power spectrum is displayed.\n"
-			"Call:\n"
-			"./dft [image_name -- default lena.jpg]\n" << endl;
+	printf("\nThis program demonstrated the use of the discrete Fourier transform (dft)\n"
+		   "The dft of an image is taken and it's power spectrum is displayed.\n"
+		   "Usage:\n"
+			"./dft [image_name -- default lena.jpg]\n");
 }
 
-
-
-int main(int argc, char ** argv)
+const char* keys = 
 {
-    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+	"{1| |lena.jpg|input image file}"
+};
 
-    Mat img = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
+int main(int argc, const char ** argv)
+{
+    help();
+	CommandLineParser parser(argc, argv, keys);
+	string filename = parser.get<string>("1");
+
+	Mat img = imread(filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
     if( img.empty() )
     {
         help();
+		printf("Cannot read image file: %s\n", filename.c_str());
         return -1;
     }
-    help();
     int M = getOptimalDFTSize( img.rows );
     int N = getOptimalDFTSize( img.cols );
     Mat padded;
diff --git a/samples/cpp/distrans.cpp b/samples/cpp/distrans.cpp
index cae24f5db5..2cae7e7544 100644
--- a/samples/cpp/distrans.cpp
+++ b/samples/cpp/distrans.cpp
@@ -5,24 +5,6 @@
 
 using namespace cv;
 
-void help()
-{
-	printf("\nProgram to demonstrate the use of the distance transform function between edge images.\n"
-			"Usage:\n"
-			"./distrans [image_name -- default image is stuff.jpg]\n"
-			);
-    printf( "\nHot keys: \n"
-        "\tESC - quit the program\n"
-        "\tC - use C/Inf metric\n"
-        "\tL1 - use L1 metric\n"
-        "\tL2 - use L2 metric\n"
-        "\t3 - use 3x3 mask\n"
-        "\t5 - use 5x5 mask\n"
-        "\t0 - use precise distance transform\n"
-        "\tv - switch Voronoi diagram mode on/off\n"
-        "\tSPACE - loop through all the modes\n" );
-}
-
 int maskSize0 = CV_DIST_MASK_5;
 bool buildVoronoi = false;
 int edgeThresh = 100;
@@ -101,17 +83,41 @@ void onTrackbar( int, void* )
     imshow("Distance Map", dist8u );
 }
 
-int main( int argc, char** argv )
+void help()
 {
-    char* filename = argc == 2 ? argv[1] : (char*)"stuff.jpg";
-    gray = imread(filename, 0);
+	printf("\nProgram to demonstrate the use of the distance transform function between edge images.\n"
+			"Usage:\n"
+			"./distrans [image_name -- default image is stuff.jpg]\n"
+			"\nHot keys: \n"
+			"\tESC - quit the program\n"
+			"\tC - use C/Inf metric\n"
+			"\tL1 - use L1 metric\n"
+			"\tL2 - use L2 metric\n"
+			"\t3 - use 3x3 mask\n"
+			"\t5 - use 5x5 mask\n"
+			"\t0 - use precise distance transform\n"
+			"\tv - switch Voronoi diagram mode on/off\n"
+			"\tSPACE - loop through all the modes\n\n");
+}
+
+const char* keys = 
+{
+	"{1| |stuff.jpg|input image file}"
+};
+
+int main( int argc, const char** argv )
+{
+    help();
+	CommandLineParser parser(argc, argv, keys);
+	string filename = parser.get<string>("1");
+	gray = imread(filename.c_str(), 0);
     if(gray.empty())
     {
-    	help();
+		printf("Cannot read image file: %s\n", filename.c_str());
+		help();
     	return -1;
     }
 
-    help();
     namedWindow("Distance Map", 1);
     createTrackbar("Brightness Threshold", "Distance Map", &edgeThresh, 255, onTrackbar, 0);
 
diff --git a/samples/cpp/drawing.cpp b/samples/cpp/drawing.cpp
index 96dcce01e4..3ff4714e38 100644
--- a/samples/cpp/drawing.cpp
+++ b/samples/cpp/drawing.cpp
@@ -1,14 +1,13 @@
 #include "opencv2/core/core.hpp"
 #include "opencv2/highgui/highgui.hpp"
-#include <iostream>
+#include <stdio.h>
 using namespace cv;
 
 void help()
 {
-	std::cout
-	<< "\nThis program demonstrates OpenCV drawing and text output functions.\n"
-	"Call:\n"
-	"./drawing\n" << std::endl;
+	printf("\nThis program demonstrates OpenCV drawing and text output functions.\n"
+	"Usage:\n"
+	"	./drawing\n");
 }
 static Scalar randomColor(RNG& rng)
 {
@@ -16,9 +15,10 @@ static Scalar randomColor(RNG& rng)
     return Scalar(icolor&255, (icolor>>8)&255, (icolor>>16)&255);
 }
 
-int main( int, char** )
+int main()
 {
-    char wndname[] = "Drawing Demo";
+    help();
+	char wndname[] = "Drawing Demo";
     const int NUMBER = 100;
     const int DELAY = 5;
     int lineType = CV_AA; // change it to 8 to see non-antialiased graphics
diff --git a/samples/cpp/edge.cpp b/samples/cpp/edge.cpp
index c30b086edf..a76176ac92 100644
--- a/samples/cpp/edge.cpp
+++ b/samples/cpp/edge.cpp
@@ -1,20 +1,11 @@
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/highgui/highgui.hpp"
 
-#include <iostream>
+#include <stdio.h>
 
 using namespace cv;
 using namespace std;
 
-void help()
-{
-	cout <<
-			"\nDemonstrate Canny edge detection\n"
-			"Call:\n"
-			"/.edge [image_name -- Default is fruits.jpg]\n" << endl;
-
-}
-
 int edgeThresh = 1;
 Mat image, gray, edge, cedge;
 
@@ -31,17 +22,32 @@ void onTrackbar(int, void*)
     imshow("Edge map", cedge);
 }
 
-int main( int argc, char** argv )
+void help()
 {
-    char* filename = argc == 2 ? argv[1] : (char*)"fruits.jpg";
+	printf("\nThis sample demonstrates Canny edge detection\n"
+		   "Call:\n"
+		   "	/.edge [image_name -- Default is fruits.jpg]\n\n");
+}
+
+const char* keys = 
+{
+	"{1| |fruits.jpg|input image name}"
+};
+
+int main( int argc, const char** argv )
+{
+    help();
+
+	CommandLineParser parser(argc, argv, keys);
+	string filename = parser.get<string>("1");
 
     image = imread(filename, 1);
     if(image.empty())
     {
-    	help();
+		printf("Cannot read image file: %s\n", filename.c_str());
+		help();
         return -1;
     }
-    help();
     cedge.create(image.size(), image.type());
     cvtColor(image, gray, CV_BGR2GRAY);
 
diff --git a/samples/cpp/fback.cpp b/samples/cpp/fback.cpp
index bf88e16a8a..d6a734e3a4 100644
--- a/samples/cpp/fback.cpp
+++ b/samples/cpp/fback.cpp
@@ -10,7 +10,7 @@ using namespace std;
 void help()
 {
 	cout <<
-			"\nThis program demonstrates dense, Farnback, optical flow\n"
+			"\nThis program demonstrates dense optical flow algorithm by Gunnar Farneback\n"
 			"Mainly the function: calcOpticalFlowFarneback()\n"
 			"Call:\n"
 			"./fback\n"
diff --git a/samples/cpp/image.cpp b/samples/cpp/image.cpp
index 8d9e8174e1..8b135347c9 100644
--- a/samples/cpp/image.cpp
+++ b/samples/cpp/image.cpp
@@ -3,7 +3,7 @@
 #include "ml.h"
 #include <stdio.h>
 #include <iostream>
-#include "opencv2/flann/flann.hpp"
+#include "opencv2/flann/miniflann.hpp"
 
 using namespace cv; // all the new API is put into "cv" namespace. Export its content
 using namespace std;
diff --git a/samples/cpp/lkdemo.cpp b/samples/cpp/lkdemo.cpp
index 94d20d3083..0185e47236 100644
--- a/samples/cpp/lkdemo.cpp
+++ b/samples/cpp/lkdemo.cpp
@@ -39,7 +39,7 @@ int main( int argc, char** argv )
 {
     VideoCapture cap;
     TermCriteria termcrit(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03);
-    Size winSize(10,10);
+    Size subPixWinSize(10,10), winSize(31,31);
     
     const int MAX_COUNT = 500;
     bool needToInit = false;
@@ -81,7 +81,7 @@ int main( int argc, char** argv )
         {
             // automatic initialization
             goodFeaturesToTrack(gray, points[1], MAX_COUNT, 0.01, 10, Mat(), 3, 0, 0.04);
-            cornerSubPix(gray, points[1], winSize, Size(-1,-1), termcrit);
+            cornerSubPix(gray, points[1], subPixWinSize, Size(-1,-1), termcrit);
             addRemovePt = false;
         }
         else if( !points[0].empty() )
@@ -91,7 +91,7 @@ int main( int argc, char** argv )
             if(prevGray.empty())
                 gray.copyTo(prevGray);
             calcOpticalFlowPyrLK(prevGray, gray, points[0], points[1], status, err, winSize,
-                                 3, termcrit, 0);
+                                 3, termcrit, 0, 0, 0.001);
             size_t i, k;
             for( i = k = 0; i < points[1].size(); i++ )
             {
diff --git a/samples/cpp/minarea.cpp b/samples/cpp/minarea.cpp
index 34afab9e0e..e7eaf72787 100644
--- a/samples/cpp/minarea.cpp
+++ b/samples/cpp/minarea.cpp
@@ -1,26 +1,28 @@
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
+
 #include <iostream>
+
 using namespace cv;
 using namespace std;
 
 void help()
 {
 	cout << "This program demonstrates finding the minimum enclosing box or circle of a set\n"
-		"of points using functions: minAreaRect() minEnclosingCircle().\n"
-		"Random points are generated and then enclosed.\n"
-		"Call:\n"
-		"./minarea\n"
-   		"Using OpenCV version %s\n" << CV_VERSION << "\n" << endl;
+            "of points using functions: minAreaRect() minEnclosingCircle().\n"
+            "Random points are generated and then enclosed.\n"
+            "Call:\n"
+            "./minarea\n"
+            "Using OpenCV version %s\n" << CV_VERSION << "\n" << endl;
 }
 
-
-
 int main( int /*argc*/, char** /*argv*/ )
 {
-    Mat img(500, 500, CV_8UC3);
-    RNG& rng = theRNG();
     help();
+
+    Mat img(500, 500, CV_8UC3);
+    RNG& rng = theRNG();    
+
     for(;;)
     {
         int i, count = rng.uniform(1, 101);
@@ -35,6 +37,7 @@ int main( int /*argc*/, char** /*argv*/ )
         }
         
         RotatedRect box = minAreaRect(Mat(points));
+
         Point2f center, vtx[4];
         float radius = 0;
         minEnclosingCircle(Mat(points), center, radius);
@@ -55,6 +58,6 @@ int main( int /*argc*/, char** /*argv*/ )
         if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
             break;
     }
+
     return 0;
 }
-
diff --git a/samples/cpp/retinaDemo.cpp b/samples/cpp/retinaDemo.cpp
new file mode 100644
index 0000000000..2ab5c55754
--- /dev/null
+++ b/samples/cpp/retinaDemo.cpp
@@ -0,0 +1,145 @@
+//============================================================================
+// Name        : retinademo.cpp
+// Author      : Alexandre Benoit, benoit.alexandre.vision@gmail.com
+// Version     : 0.1
+// Copyright   : LISTIC/GIPSA French Labs, july 2011
+// Description : Gipsa/LISTIC Labs retina demo in C++, Ansi-style
+//============================================================================
+
+#include <iostream>
+#include <cstring>
+
+#include "opencv2/opencv.hpp"
+
+void help(std::string errorMessage)
+{
+	std::cout<<"Program init error : "<<errorMessage<<std::endl;
+	std::cout<<"\nProgram call procedure : retinaDemo [processing mode] [Optional : media target] [Optional LAST parameter: \"log\" to activate retina log sampling]"<<std::endl;
+	std::cout<<"\t[processing mode] :"<<std::endl;
+	std::cout<<"\t -image : for still image processing"<<std::endl;
+	std::cout<<"\t -video : for video stream processing"<<std::endl;
+	std::cout<<"\t[Optional : media target] :"<<std::endl;
+	std::cout<<"\t if processing an image or video file, then, specify the path and filename of the target to process"<<std::endl;
+	std::cout<<"\t leave empty if processing video stream coming from a connected video device"<<std::endl;
+	std::cout<<"\t[Optional : activate retina log sampling] : an optional last parameter can be specified for retina spatial log sampling"<<std::endl;
+	std::cout<<"\t set \"log\" without quotes to activate this sampling, output frame size will be divided by 4"<<std::endl;
+	std::cout<<"\nExamples:"<<std::endl;
+	std::cout<<"\t-Image processing : ./retinaDemo -image lena.jpg"<<std::endl;
+	std::cout<<"\t-Image processing with log sampling : ./retinaDemo -image lena.jpg log"<<std::endl;
+	std::cout<<"\t-Video processing : ./retinaDemo -video myMovie.mp4"<<std::endl;
+	std::cout<<"\t-Live video processing : ./retinaDemo -video"<<std::endl;
+	std::cout<<"\nPlease start again with new parameters"<<std::endl;
+}
+
+int main(int argc, char* argv[]) {
+	// welcome message
+	std::cout<<"****************************************************"<<std::endl;
+	std::cout<<"* Retina demonstration : demonstrates the use of is a wrapper class of the Gipsa/Listic Labs retina model."<<std::endl;
+	std::cout<<"* This retina model allows spatio-temporal image processing (applied on still images, video sequences)."<<std::endl;
+	std::cout<<"* As a summary, these are the retina model properties:"<<std::endl;
+	std::cout<<"* => It applies a spectral whithening (mid-frequency details enhancement)"<<std::endl;
+	std::cout<<"* => high frequency spatio-temporal noise reduction"<<std::endl;
+	std::cout<<"* => low frequency luminance to be reduced (luminance range compression)"<<std::endl;
+	std::cout<<"* => local logarithmic luminance compression allows details to be enhanced in low light conditions\n"<<std::endl;
+	std::cout<<"* for more information, reer to the following papers :"<<std::endl;
+	std::cout<<"* Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011"<<std::endl;
+	std::cout<<"* Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891."<<std::endl;
+	std::cout<<"* => reports comments/remarks at benoit.alexandre.vision@gmail.com"<<std::endl;
+	std::cout<<"****************************************************"<<std::endl;
+
+	// basic input arguments checking
+	if (argc<2)
+	{
+		help("bad number of parameter");
+		return -1;
+	}
+
+	bool useLogSampling = !strcmp(argv[argc-1], "log"); // check if user wants retina log sampling processing
+
+	std::string inputMediaType=argv[1];
+
+	// declare the retina input buffer... that will be fed differently in regard of the input media
+	cv::Mat inputFrame;
+	cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
+
+	//////////////////////////////////////////////////////////////////////////////
+	// checking input media type (still image, video file, live video acquisition)
+	if (!strcmp(inputMediaType.c_str(), "-image") && argc >= 3)
+	{
+		std::cout<<"RetinaDemo: processing image "<<argv[2]<<std::endl;
+		// image processing case
+		inputFrame = cv::imread(std::string(argv[2]), 1); // load image in RGB mode
+	}else
+		if (!strcmp(inputMediaType.c_str(), "-video"))
+		{
+			if (argc == 2 || (argc == 3 && useLogSampling)) // attempt to grab images from a video capture device
+			{
+				videoCapture.open(0);
+			}else// attempt to grab images from a video filestream
+			{
+				std::cout<<"RetinaDemo: processing video stream "<<argv[2]<<std::endl;
+				videoCapture.open(argv[2]);
+			}
+
+			// grab a first frame to check if everything is ok
+			videoCapture>>inputFrame;
+		}else
+		{
+			// bad command parameter
+			help("bad command parameter");
+			return -1;
+		}
+
+	if (inputFrame.empty())
+	{
+		help("Input media could not be loaded, aborting");
+		return -1;
+	}
+
+
+	//////////////////////////////////////////////////////////////////////////////
+	// Program start in a try/catch safety context (Retina may throw errors)
+	try
+	{
+		// create a retina instance with default parameters setup, uncomment the initialisation you wanna test
+		cv::Ptr<cv::Retina> myRetina;
+
+		// if the last parameter is 'log', then activate log sampling (favour foveal vision and subsamples peripheral vision)
+		if (useLogSampling)
+			myRetina = new cv::Retina("params.xml", inputFrame.size(), true, cv::RETINA_COLOR_BAYER, true, 2.0, 10.0);
+		else// -> else allocate "classical" retina :
+			myRetina = new cv::Retina("params.xml", inputFrame.size());
+
+		// declare retina output buffers
+		cv::Mat retinaOutput_parvo;
+		cv::Mat retinaOutput_magno;
+
+		// processing loop with stop condition
+		bool continueProcessing=true; // FIXME : not yet managed during process...
+		while(continueProcessing)
+		{
+			// if using video stream, then, grabbing a new frame, else, input remains the same
+			if (videoCapture.isOpened())
+				videoCapture>>inputFrame;
+
+			// run retina filter
+			myRetina->run(inputFrame);
+			// Retrieve and display retina output
+			myRetina->getParvo(retinaOutput_parvo);
+			myRetina->getMagno(retinaOutput_magno);
+			cv::imshow("retina input", inputFrame);
+			cv::imshow("Retina Parvo", retinaOutput_parvo);
+			cv::imshow("Retina Magno", retinaOutput_magno);
+			cv::waitKey(10);
+		}
+	}catch(cv::Exception e)
+	{
+		std::cerr<<"Error using Retina : "<<e.what()<<std::endl;
+	}
+
+	// Program end message
+	std::cout<<"Retina demo end"<<std::endl;
+
+	return 0;
+}
+
diff --git a/samples/cpp/stereo_match.cpp b/samples/cpp/stereo_match.cpp
index 245c9ed389..08f67e3239 100644
--- a/samples/cpp/stereo_match.cpp
+++ b/samples/cpp/stereo_match.cpp
@@ -20,7 +20,7 @@ void print_help()
 {
 	printf("\nDemo stereo matching converting L and R images into disparity and point clouds\n");
     printf("\nUsage: stereo_match <left_image> <right_image> [--algorithm=bm|sgbm|hh|var] [--blocksize=<block_size>]\n"
-           "[--max-disparity=<max_disparity>] [-i <intrinsic_filename>] [-e <extrinsic_filename>]\n"
+           "[--max-disparity=<max_disparity>] [--scale=scale_factor>] [-i <intrinsic_filename>] [-e <extrinsic_filename>]\n"
            "[--no-display] [-o <disparity_image>] [-p <point_cloud_file>]\n");
 }
 
@@ -40,18 +40,18 @@ void saveXYZ(const char* filename, const Mat& mat)
     fclose(fp);
 }
 
-
 int main(int argc, char** argv)
 {
     const char* algorithm_opt = "--algorithm=";
     const char* maxdisp_opt = "--max-disparity=";
     const char* blocksize_opt = "--blocksize=";
     const char* nodisplay_opt = "--no-display=";
+    const char* scale_opt = "--scale=";
     
     if(argc < 3)
     {
         print_help();
-        return 0;
+		return 0;
     }
     const char* img1_filename = 0;
     const char* img2_filename = 0;
@@ -64,6 +64,7 @@ int main(int argc, char** argv)
     int alg = STEREO_SGBM;
     int SADWindowSize = 0, numberOfDisparities = 0;
     bool no_display = false;
+    float scale = 1.f;
     
     StereoBM bm;
     StereoSGBM sgbm;
@@ -111,6 +112,14 @@ int main(int argc, char** argv)
                 return -1;
             }
         }
+        else if( strncmp(argv[i], scale_opt, strlen(scale_opt)) == 0 )
+        {
+            if( sscanf( argv[i] + strlen(scale_opt), "%f", &scale ) != 1 || scale < 0 )
+            {
+                printf("Command-line parameter error: The scale factor (--scale=<...>) must be a positive floating-point number\n");
+                return -1;
+            }
+        }
         else if( strcmp(argv[i], nodisplay_opt) == 0 )
             no_display = true;
         else if( strcmp(argv[i], "-i" ) == 0 )
@@ -149,6 +158,17 @@ int main(int argc, char** argv)
     int color_mode = alg == STEREO_BM ? 0 : -1;
     Mat img1 = imread(img1_filename, color_mode);
     Mat img2 = imread(img2_filename, color_mode);
+    
+    if( scale != 1.f )
+    {
+        Mat temp1, temp2;
+        int method = scale < 1 ? INTER_AREA : INTER_CUBIC;
+        resize(img1, temp1, Size(), scale, scale, method);
+        img1 = temp1;
+        resize(img2, temp2, Size(), scale, scale, method);
+        img2 = temp2;
+    }
+    
     Size img_size = img1.size();
     
     Rect roi1, roi2;
@@ -224,18 +244,18 @@ int main(int argc, char** argv)
     sgbm.disp12MaxDiff = 1;
     sgbm.fullDP = alg == STEREO_HH;
     
-    var.levels = 6;
-	var.pyrScale = 0.6;
-	var.nIt = 3;
-	var.minDisp = -numberOfDisparities;
+    var.levels = 3;									// ignored with USE_AUTO_PARAMS
+	var.pyrScale = 0.5;								// ignored with USE_AUTO_PARAMS
+	var.nIt = 25;
+	var.minDisp = -numberOfDisparities;	
 	var.maxDisp = 0;
 	var.poly_n = 3;
 	var.poly_sigma = 0.0;
-	var.fi = 5.0f;
-	var.lambda = 0.1;
-	var.penalization = var.PENALIZATION_TICHONOV;
-	var.cycle = var.CYCLE_V;
-	var.flags = var.USE_SMART_ID | var.USE_INITIAL_DISPARITY | 1 * var.USE_MEDIAN_FILTERING ;
+	var.fi = 15.0f;
+	var.lambda = 0.03f;
+	var.penalization = var.PENALIZATION_TICHONOV;	// ignored with USE_AUTO_PARAMS
+	var.cycle = var.CYCLE_V;						// ignored with USE_AUTO_PARAMS
+	var.flags = var.USE_SMART_ID | var.USE_AUTO_PARAMS | var.USE_INITIAL_DISPARITY | var.USE_MEDIAN_FILTERING ;
     
     Mat disp, disp8;
     //Mat img1p, img2p, dispp;
@@ -245,8 +265,9 @@ int main(int argc, char** argv)
     int64 t = getTickCount();
     if( alg == STEREO_BM )
         bm(img1, img2, disp);
-    else if( alg == STEREO_VAR )
+    else if( alg == STEREO_VAR ) {
         var(img1, img2, disp);
+	}
     else if( alg == STEREO_SGBM || alg == STEREO_HH )
         sgbm(img1, img2, disp);
     t = getTickCount() - t;
diff --git a/samples/cpp/tutorial_code/Basic/DisplayImage.cpp b/samples/cpp/tutorial_code/Basic/DisplayImage.cpp
deleted file mode 100644
index 99ce674c3d..0000000000
--- a/samples/cpp/tutorial_code/Basic/DisplayImage.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * @file DisplayImage.cpp
- * @brief Sample code that show how to read and display an image in a OpenCV window
- * @author OpenCV team
- */
-#include <cv.h>
-#include <highgui.h>
-
-using namespace cv;
-
-int main( int argc, char** argv )
-{
-   Mat image;
-   image = imread( argv[1], 1 );
-
-   if( argc != 2 || !image.data )
-     { 
-       printf( "No image data \n" );
-       return -1; 
-     }
-
-   namedWindow( "Display Image", CV_WINDOW_AUTOSIZE );
-   imshow( "Display Image", image );
-
-   waitKey(0);
-
-   return 0;
-}
diff --git a/samples/cpp/tutorial_code/Basic/LoadSaveImage.cpp b/samples/cpp/tutorial_code/Basic/LoadSaveImage.cpp
deleted file mode 100644
index 69db8e3e98..0000000000
--- a/samples/cpp/tutorial_code/Basic/LoadSaveImage.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * @file LoadSaveImage.cpp
- * @brief Sample code that load an image, modify it and save the new image.  
- * @author OpenCV team
- */
-
-#include <cv.h>
-#include <highgui.h>
-
-using namespace cv;
-
-/**
- * @function main
- * @brief Self-explanatory
- */
-int main( int argc, char** argv )
-{
-  /// Get the name of the file to be loaded
-  char* imageName = argv[1];
-
-  /// Create a Mat object
-  Mat image;
-  
-  /// Load the image using imread
-  image = imread( imageName, 1 );
-  
-  /// Verify that the image was loaded
-  if( argc != 2 || !image.data )
-    {
-      printf( " No image data \n " );
-      return -1;
-    }
-
-  /// Change the image to Grayscale
-  Mat gray_image;
-  cvtColor( image, gray_image, CV_RGB2GRAY );
-
-  /// Save our gray image
-  imwrite( "../images/Gray_Image.png", gray_image );
-
-  /// Create a couple of windows and show our images
-  namedWindow( imageName, CV_WINDOW_AUTOSIZE );
-  namedWindow( "Gray image", CV_WINDOW_AUTOSIZE );
-
-  imshow( imageName, image );
-  imshow( "Gray image", gray_image ); 
-
-  /// Wait until user finish the application   
-  waitKey(0);
-
-  return 0;
-}
diff --git a/samples/cpp/tutorial_code/Basic/AddingImagesTrackbar.cpp b/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/AddingImagesTrackbar.cpp
rename to samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp
diff --git a/samples/cpp/tutorial_code/Basic/BasicLinearTransformsTrackbar.cpp b/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/BasicLinearTransformsTrackbar.cpp
rename to samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp
diff --git a/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video-input-psnr-ssim.cpp b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video-input-psnr-ssim.cpp
new file mode 100644
index 0000000000..24d13af783
--- /dev/null
+++ b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video-input-psnr-ssim.cpp
@@ -0,0 +1,205 @@
+#include <iostream>	// for standard I/O
+#include <string>   // for strings
+#include <iomanip>  // for controlling float print precision
+#include <sstream>  // string to number conversion
+
+#include <opencv2/imgproc/imgproc.hpp>  // Gaussian Blur
+#include <opencv2/core/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/highgui/highgui.hpp>  // OpenCV window I/O
+
+using namespace std;
+using namespace cv;
+
+double getPSNR ( const Mat& I1, const Mat& I2);
+Scalar getMSSIM( const Mat& I1, const Mat& I2);
+
+void help()
+{
+    cout
+        << "\n--------------------------------------------------------------------------" << endl
+        << "This program shows how to read a video file with OpenCV. In addition, it tests the"
+        << " similarity of two input videos first with PSNR, and for the frames below a PSNR "  << endl
+        << "trigger value, also with MSSIM."<< endl
+        << "Usage:"                                                                       << endl
+        << "./video-source referenceVideo useCaseTestVideo PSNR_Trigger_Value Wait_Between_Frames " << endl
+        << "--------------------------------------------------------------------------"   << endl
+        << endl;
+}
+int main(int argc, char *argv[], char *window_name)
+{
+    help();
+    if (argc != 5)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1;
+    }
+    stringstream conv;
+
+    const string sourceReference = argv[1],sourceCompareWith = argv[2];
+    int psnrTriggerValue, delay;
+    conv << argv[3] << endl << argv[4];		  // put in the strings
+    conv >> psnrTriggerValue >> delay;// take out the numbers
+
+    char c;
+    int frameNum = -1;			// Frame counter
+
+    VideoCapture captRefrnc(sourceReference),
+        captUndTst(sourceCompareWith);
+
+    if ( !captRefrnc.isOpened())
+    {
+        cout  << "Could not open reference " << sourceReference << endl;
+        return -1;
+    }
+
+    if( !captUndTst.isOpened())
+    {
+        cout  << "Could not open case test " << sourceCompareWith << endl;
+        return -1;
+    }
+
+    Size refS = Size((int) captRefrnc.get(CV_CAP_PROP_FRAME_WIDTH),
+        (int) captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
+        uTSi = Size((int) captUndTst.get(CV_CAP_PROP_FRAME_WIDTH),
+        (int) captUndTst.get(CV_CAP_PROP_FRAME_HEIGHT));
+
+    if (refS != uTSi)
+    {
+        cout << "Inputs have different size!!! Closing." << endl;
+        return -1;
+    }
+
+    const char* WIN_UT = "Under Test";
+    const char* WIN_RF = "Reference";
+
+    // Windows
+    namedWindow(WIN_RF, CV_WINDOW_AUTOSIZE );
+    namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE );
+    cvMoveWindow(WIN_RF, 400       ,            0);		 //750,  2 (bernat =0)
+    cvMoveWindow(WIN_UT, refS.width,            0);		 //1500, 2
+
+    cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
+        << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
+
+    cout << "PSNR trigger value " <<
+        setiosflags(ios::fixed) << setprecision(3) << psnrTriggerValue << endl;
+
+    Mat frameReference, frameUnderTest;
+    double psnrV;
+    Scalar mssimV;
+
+    while( true) //Show the image captured in the window and repeat
+    {
+        captRefrnc >> frameReference;
+        captUndTst >> frameUnderTest;
+
+        if( frameReference.empty()  || frameUnderTest.empty())
+        {
+            cout << " < < <  Game over!  > > > ";
+            break;
+        }
+
+        ++frameNum;
+        cout <<"Frame:" << frameNum <<"# ";
+
+        ///////////////////////////////// PSNR ////////////////////////////////////////////////////
+        psnrV = getPSNR(frameReference,frameUnderTest);					//get PSNR
+        cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";
+
+        //////////////////////////////////// MSSIM /////////////////////////////////////////////////
+        if (psnrV < psnrTriggerValue && psnrV)
+        {
+            mssimV = getMSSIM(frameReference,frameUnderTest);
+
+            cout << " MSSIM: "
+                << " R " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[2] * 100 << "%"
+                << " G " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[1] * 100 << "%"
+                << " B " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[0] * 100 << "%";
+        }
+
+        cout << endl;
+
+        ////////////////////////////////// Show Image /////////////////////////////////////////////
+        imshow( WIN_RF, frameReference);
+        imshow( WIN_UT, frameUnderTest);
+
+        c = cvWaitKey(delay);
+        if (c == 27) break;
+    }
+
+    return 0;
+}
+
+double getPSNR(const Mat& I1, const Mat& I2)
+{
+    Mat s1;
+    absdiff(I1, I2, s1);       // |I1 - I2|
+    s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
+    s1 = s1.mul(s1);           // |I1 - I2|^2
+
+    Scalar s = sum(s1);         // sum elements per channel
+
+    double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double  mse =sse /(double)(I1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+}
+
+Scalar getMSSIM( const Mat& i1, const Mat& i2)
+{
+    const double C1 = 6.5025, C2 = 58.5225;
+    /***************************** INITS **********************************/
+    int d     = CV_32F;
+
+    Mat I1, I2;
+    i1.convertTo(I1, d);           // cannot calculate on one byte large values
+    i2.convertTo(I2, d);
+
+    Mat I2_2   = I2.mul(I2);        // I2^2
+    Mat I1_2   = I1.mul(I1);        // I1^2
+    Mat I1_I2  = I1.mul(I2);        // I1 * I2
+
+    /*************************** END INITS **********************************/
+
+    Mat mu1, mu2;   // PRELIMINARY COMPUTING
+    GaussianBlur(I1, mu1, Size(11, 11), 1.5);
+    GaussianBlur(I2, mu2, Size(11, 11), 1.5);
+
+    Mat mu1_2   =   mu1.mul(mu1);
+    Mat mu2_2   =   mu2.mul(mu2);
+    Mat mu1_mu2 =   mu1.mul(mu2);
+
+    Mat sigma1_2, sigma2_2, sigma12;
+
+    GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    ///////////////////////////////// FORMULA ////////////////////////////////
+    Mat t1, t2, t3;
+
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    Mat ssim_map;
+    divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
+
+    Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
+    return mssim;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind.avi b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind.avi
new file mode 100644
index 0000000000..86351eb018
Binary files /dev/null and b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind.avi differ
diff --git a/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind_bugy.avi b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind_bugy.avi
new file mode 100644
index 0000000000..67ab6bec1e
Binary files /dev/null and b/samples/cpp/tutorial_code/HighGUI/video-input-psnr-ssim/video/Megamind_bugy.avi differ
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp
new file mode 100644
index 0000000000..dce01387ca
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp
@@ -0,0 +1,51 @@
+/**
+ * @function EqualizeHist_Demo.cpp
+ * @brief Demo code for equalizeHist function
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  Mat src, dst;
+
+  char* source_window = "Source image";
+  char* equalized_window = "Equalized Image";
+
+  /// Load image
+  src = imread( argv[1], 1 );
+
+  if( !src.data )
+    { cout<<"Usage: ./Histogram_Demo <path_to_image>"<<endl;
+      return -1; 
+    }
+
+  /// Convert to grayscale
+  cvtColor( src, src, CV_BGR2GRAY );
+
+  /// Apply Histogram Equalization
+  equalizeHist( src, dst );
+ 
+  /// Display results
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  namedWindow( equalized_window, CV_WINDOW_AUTOSIZE );
+
+  imshow( source_window, src );
+  imshow( equalized_window, dst );
+ 
+  /// Wait until user exits the program 
+  waitKey(0);
+
+  return 0;
+
+}
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
new file mode 100644
index 0000000000..f1f2cd5d16
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
@@ -0,0 +1,90 @@
+/**
+ * @file MatchTemplate_Demo.cpp
+ * @brief Sample code to use the function MatchTemplate
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+
+/// Global Variables
+Mat img; Mat templ; Mat result;
+char* image_window = "Source Image";
+char* result_window = "Result window";
+
+int match_method;
+int max_Trackbar = 5;
+
+/// Function Headers
+void MatchingMethod( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load image and template
+  img = imread( argv[1], 1 );
+  templ = imread( argv[2], 1 );
+
+  /// Create windows
+  namedWindow( image_window, CV_WINDOW_AUTOSIZE );
+  namedWindow( result_window, CV_WINDOW_AUTOSIZE );
+  
+  /// Create Trackbar
+  char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+  createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
+
+  MatchingMethod( 0, 0 );
+
+  waitKey(0);
+  return 0;
+}
+
+/**
+ * @function MatchingMethod
+ * @brief Trackbar callback
+ */
+void MatchingMethod( int, void* )
+{
+  /// Source image to display
+  Mat img_display;
+  img.copyTo( img_display );
+ 
+  /// Create the result matrix
+  int result_cols =  img.cols - templ.cols + 1;
+  int result_rows = img.rows - templ.rows + 1;   
+  
+  result.create( result_cols, result_rows, CV_32FC1 );
+
+  /// Do the Matching and Normalize
+  matchTemplate( img, templ, result, match_method );
+  normalize( result, result, 0, 1, NORM_MINMAX, -1, Mat() );
+
+  /// Localizing the best match with minMaxLoc
+  double minVal; double maxVal; Point minLoc; Point maxLoc;
+  Point matchLoc;
+ 
+  minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
+
+
+  /// For SQDIFF and SQDIFF_NORMED, the best matches are lower values. For all the other methods, the higher the better
+  if( match_method  == CV_TM_SQDIFF || match_method == CV_TM_SQDIFF_NORMED )
+    { matchLoc = minLoc; }
+  else  
+    { matchLoc = maxLoc; }
+
+  /// Show me what you got
+  rectangle( img_display, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+  rectangle( result, matchLoc, Point( matchLoc.x + templ.cols , matchLoc.y + templ.rows ), Scalar::all(0), 2, 8, 0 ); 
+
+  imshow( image_window, img_display );
+  imshow( result_window, result );
+
+  return;
+}
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp
new file mode 100644
index 0000000000..290b3b1341
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp
@@ -0,0 +1,85 @@
+/**
+ * @file BackProject_Demo1.cpp
+ * @brief Sample code for backproject function usage
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat src; Mat hsv; Mat hue; 
+int bins = 25;
+
+/// Function Headers
+void Hist_and_Backproj(int, void* );
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Read the image
+  src = imread( argv[1], 1 );
+  /// Transform it to HSV
+  cvtColor( src, hsv, CV_BGR2HSV );
+
+  /// Use only the Hue value
+  hue.create( hsv.size(), hsv.depth() );
+  int ch[] = { 0, 0 };
+  mixChannels( &hsv, 1, &hue, 1, ch, 1 );  
+
+  /// Create Trackbar to enter the number of bins
+  char* window_image = "Source image";
+  namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+  createTrackbar("* Hue  bins: ", window_image, &bins, 180, Hist_and_Backproj );
+  Hist_and_Backproj(0, 0);
+
+  /// Show the image
+  imshow( window_image, src );
+
+  /// Wait until user exits the program
+  waitKey(0);
+  return 0;
+}
+
+
+/**
+ * @function Hist_and_Backproj
+ * @brief Callback to Trackbar
+ */
+void Hist_and_Backproj(int, void* )
+{
+  MatND hist;
+  int histSize = MAX( bins, 2 ); 
+  float hue_range[] = { 0, 180 };
+  const float* ranges = { hue_range };
+
+  /// Get the Histogram and normalize it
+  calcHist( &hue, 1, 0, Mat(), hist, 1, &histSize, &ranges, true, false );
+  normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+  /// Get Backprojection
+  MatND backproj;
+  calcBackProject( &hue, 1, 0, hist, backproj, &ranges, 1, true );
+ 
+  /// Draw the backproj
+  imshow( "BackProj", backproj );
+
+  /// Draw the histogram
+  int w = 400; int h = 400;
+  int bin_w = cvRound( (double) w / histSize ); 
+  Mat histImg = Mat::zeros( w, h, CV_8UC3 );
+
+  for( int i = 0; i < bins; i ++ )  
+     { rectangle( histImg, Point( i*bin_w, h ), Point( (i+1)*bin_w, h - cvRound( hist.at<float>(i)*h/255.0 ) ), Scalar( 0, 0, 255 ), -1 ); }
+
+  imshow( "Histogram", histImg );
+
+}
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp
new file mode 100644
index 0000000000..98b86e9c09
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp
@@ -0,0 +1,103 @@
+/**
+ * @file BackProject_Demo2.cpp
+ * @brief Sample code for backproject function usage ( a bit more elaborated )
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/// Global Variables
+Mat src; Mat hsv; 
+Mat mask;
+
+int lo = 20; int up = 20;
+char* window_image = "Source image";
+
+/// Function Headers
+void Hist_and_Backproj( );
+void pickPoint (int event, int x, int y, int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Read the image
+  src = imread( argv[1], 1 );
+  /// Transform it to HSV
+  cvtColor( src, hsv, CV_BGR2HSV );
+
+  /// Show the image 
+  namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+  imshow( window_image, src );
+
+  /// Set Trackbars for floodfill thresholds
+  createTrackbar( "Low thresh", window_image, &lo, 255, 0 );
+  createTrackbar( "High thresh", window_image, &up, 255, 0 );
+  /// Set a Mouse Callback
+  setMouseCallback( window_image, pickPoint, 0 );
+
+  waitKey(0);
+  return 0;
+}
+
+/**
+ * @function pickPoint
+ */
+void pickPoint (int event, int x, int y, int, void* )
+{
+  if( event != CV_EVENT_LBUTTONDOWN )
+    { return; }
+
+  // Fill and get the mask
+  Point seed = Point( x, y );
+ 
+  int newMaskVal = 255;
+  Scalar newVal = Scalar( 120, 120, 120 );
+
+  int connectivity = 8;
+  int flags = connectivity + (newMaskVal << 8 ) + FLOODFILL_FIXED_RANGE + FLOODFILL_MASK_ONLY;
+
+  Mat mask2 = Mat::zeros( src.rows + 2, src.cols + 2, CV_8UC1 );
+  floodFill( src, mask2, seed, newVal, 0, Scalar( lo, lo, lo ), Scalar( up, up, up), flags ); 
+  mask = mask2( Range( 1, mask2.rows - 1 ), Range( 1, mask2.cols - 1 ) );
+
+  imshow( "Mask", mask );
+
+  Hist_and_Backproj( );
+}
+
+/**
+ * @function Hist_and_Backproj
+ */
+void Hist_and_Backproj( )
+{
+  MatND hist;
+  int h_bins = 30; int s_bins = 32;
+  int histSize[] = { h_bins, s_bins }; 
+
+  float h_range[] = { 0, 179 };
+  float s_range[] = { 0, 255 };
+  const float* ranges[] = { h_range, s_range };
+
+  int channels[] = { 0, 1 };
+
+  /// Get the Histogram and normalize it
+  calcHist( &hsv, 1, channels, mask, hist, 2, histSize, ranges, true, false );
+
+  normalize( hist, hist, 0, 255, NORM_MINMAX, -1, Mat() );
+
+  /// Get Backprojection
+  MatND backproj;
+  calcBackProject( &hsv, 1, channels, hist, backproj, ranges, 1, true );
+ 
+  /// Draw the backproj
+  imshow( "BackProj", backproj );
+
+}
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp
new file mode 100644
index 0000000000..ae2496320c
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp
@@ -0,0 +1,81 @@
+/**
+ * @function calcHist_Demo.cpp
+ * @brief Demo code to use the function calcHist
+ * @author
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  Mat src, dst;
+
+  /// Load image
+  src = imread( argv[1], 1 );
+
+  if( !src.data )
+    { return -1; }
+
+  /// Separate the image in 3 places ( R, G and B )
+  vector<Mat> rgb_planes;
+  split( src, rgb_planes ); 
+
+  /// Establish the number of bins 
+  int histSize = 255;
+
+  /// Set the ranges ( for R,G,B) )
+  float range[] = { 0, 255 } ; 
+  const float* histRange = { range };
+
+  bool uniform = true; bool accumulate = false;
+
+  Mat r_hist, g_hist, b_hist;
+
+  /// Compute the histograms:
+  calcHist( &rgb_planes[0], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );
+  calcHist( &rgb_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
+  calcHist( &rgb_planes[2], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
+
+  // Draw the histograms for R, G and B
+  int hist_w = 400; int hist_h = 400;
+  int bin_w = cvRound( (double) hist_w/histSize );
+
+  Mat histImage( hist_w, hist_h, CV_8UC3, Scalar( 0,0,0) );
+
+  /// Normalize the result to [ 0, histImage.rows ]
+  normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+  normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+  normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
+
+  /// Draw for each channel 
+  for( int i = 1; i < histSize; i++ )
+    { 
+      line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) , 
+		       Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), 
+	               Scalar( 0, 0, 255), 2, 8, 0  ); 
+      line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) , 
+		       Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ), 
+	               Scalar( 0, 255, 0), 2, 8, 0  ); 
+      line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) , 
+		       Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), 
+	               Scalar( 255, 0, 0), 2, 8, 0  );       
+    }
+
+ /// Display 
+  namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
+  imshow("calcHist Demo", histImage );
+
+  waitKey(0);
+
+  return 0;
+ 
+}
diff --git a/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
new file mode 100644
index 0000000000..3bc60fefbd
--- /dev/null
+++ b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
@@ -0,0 +1,89 @@
+/**
+ * @file compareHist_Demo.cpp
+ * @brief Sample code to use the function compareHist
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace std;
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+    Mat src_base, hsv_base;
+    Mat src_test1, hsv_test1;
+    Mat src_test2, hsv_test2;
+    Mat hsv_half_down;
+
+   /// Load three images with different environment settings
+   if( argc < 4 )
+     { printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
+       return -1; 
+     }
+
+   src_base = imread( argv[1], 1 );
+   src_test1 = imread( argv[2], 1 );
+   src_test2 = imread( argv[3], 1 );
+
+   /// Convert to HSV
+   cvtColor( src_base, hsv_base, CV_BGR2HSV );
+   cvtColor( src_test1, hsv_test1, CV_BGR2HSV );
+   cvtColor( src_test2, hsv_test2, CV_BGR2HSV );
+
+   hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );  
+
+   /// Using 30 bins for hue and 32 for saturation
+    int h_bins = 50; int s_bins = 60;
+    int histSize[] = { h_bins, s_bins };
+
+    // hue varies from 0 to 256, saturation from 0 to 180
+    float h_ranges[] = { 0, 256 };
+    float s_ranges[] = { 0, 180 };
+
+    const float* ranges[] = { h_ranges, s_ranges };
+
+    // Use the o-th and 1-st channels
+    int channels[] = { 0, 1 };
+
+
+    /// Histograms
+    MatND hist_base;
+    MatND hist_half_down;
+    MatND hist_test1;
+    MatND hist_test2;
+
+    /// Calculate the histograms for the HSV images
+    calcHist( &hsv_base, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
+    normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_half_down, 1, channels, Mat(), hist_half_down, 2, histSize, ranges, true, false );
+    normalize( hist_half_down, hist_half_down, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test1, 1, channels, Mat(), hist_test1, 2, histSize, ranges, true, false );
+    normalize( hist_test1, hist_test1, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    calcHist( &hsv_test2, 1, channels, Mat(), hist_test2, 2, histSize, ranges, true, false );
+    normalize( hist_test2, hist_test2, 0, 1, NORM_MINMAX, -1, Mat() );
+
+    /// Apply the histogram comparison methods
+    for( int i = 0; i < 4; i++ )
+       { int compare_method = i; 
+         double base_base = compareHist( hist_base, hist_base, compare_method );
+         double base_half = compareHist( hist_base, hist_half_down, compare_method );
+         double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+         double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+     
+         printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
+       } 
+
+    printf( "Done \n" );
+
+    return 0;
+}
diff --git a/samples/cpp/tutorial_code/Basic/AddingImages.cpp b/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/AddingImages.cpp
rename to samples/cpp/tutorial_code/ImgProc/AddingImages.cpp
diff --git a/samples/cpp/tutorial_code/Basic/BasicLinearTransforms.cpp b/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/BasicLinearTransforms.cpp
rename to samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp
diff --git a/samples/cpp/tutorial_code/Image_Processing/Morphology_1.cpp b/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Image_Processing/Morphology_1.cpp
rename to samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
diff --git a/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp b/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
new file mode 100644
index 0000000000..12388d0870
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
@@ -0,0 +1,80 @@
+/**
+ * @file Morphology_2.cpp
+ * @brief Advanced morphology Transformations sample code
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global variables
+Mat src, dst;
+
+int morph_elem = 0;
+int morph_size = 0;
+int morph_operator = 0;
+int const max_operator = 4;
+int const max_elem = 2;
+int const max_kernel_size = 21;
+
+char* window_name = "Morphology Transformations Demo";
+
+
+/** Function Headers */
+void Morphology_Operations( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load an image
+  src = imread( argv[1] );
+
+  if( !src.data )
+    { return -1; }
+    
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Create Trackbar to select Morphology operation
+  createTrackbar("Operator:\n 0: Opening - 1: Closing  \n 2: Gradient - 3: Top Hat \n 4: Black Hat", window_name, &morph_operator, max_operator, Morphology_Operations );
+
+  /// Create Trackbar to select kernel type
+  createTrackbar( "Element:\n 0: Rect - 1: Cross - 2: Ellipse", window_name, 
+		  &morph_elem, max_elem, 
+		  Morphology_Operations );
+
+  /// Create Trackbar to choose kernel size
+  createTrackbar( "Kernel size:\n 2n +1", window_name, 
+		  &morph_size, max_kernel_size,
+		  Morphology_Operations );
+
+  /// Default start
+  Morphology_Operations( 0, 0 );
+
+  waitKey(0);
+  return 0;
+}
+
+/** 
+ * @function Morphology_Operations
+ */
+void Morphology_Operations( int, void* )
+{
+
+  // Since MORPH_X : 2,3,4,5 and 6
+  int operation = morph_operator + 2;
+
+  Mat element = getStructuringElement( morph_elem, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) ); 
+
+  /// Apply the specified morphology operation
+  morphologyEx( src, dst, operation, element );
+  imshow( window_name, dst );  
+}
+
+
diff --git a/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp b/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp
new file mode 100644
index 0000000000..42070e9754
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp
@@ -0,0 +1,75 @@
+/**
+ * @file Pyramids.cpp
+ * @brief Sample code of image pyramids (pyrDown and pyrUp)
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global variables
+Mat src, dst, tmp;
+
+char* window_name = "Pyramids Demo";
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// General instructions
+  printf( "\n Zoom In-Out demo  \n " );
+  printf( "------------------ \n" );
+  printf( " * [u] -> Zoom in  \n" );
+  printf( " * [d] -> Zoom out \n" );
+  printf( " * [ESC] -> Close program \n \n" );
+
+  /// Test image - Make sure it s divisible by 2^{n}
+  src = imread( "../images/chicky_512.png" );
+  if( !src.data )
+    { printf(" No data! -- Exiting the program \n");
+      return -1; }
+
+  tmp = src;  
+  dst = tmp;
+
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+  imshow( window_name, dst );
+
+  /// Loop
+  while( true )
+  { 
+    int c;
+    c = waitKey(10);
+
+    if( (char)c == 27 )
+      { break; }
+    if( (char)c == 'u' )
+      { pyrUp( tmp, dst, Size( tmp.cols*2, tmp.rows*2 ) );
+        printf( "** Zoom In: Image x 2 \n" ); 
+      }
+    else if( (char)c == 'd' )
+      { pyrDown( tmp, dst, Size( tmp.cols/2, tmp.rows/2 ) );
+        printf( "** Zoom Out: Image / 2 \n" );
+      }
+
+    imshow( window_name, dst );
+    tmp = dst;
+   }  
+    
+   return 0;
+}
+
+
+
+
+
+
+
diff --git a/samples/cpp/tutorial_code/Image_Processing/Smoothing.cpp b/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Image_Processing/Smoothing.cpp
rename to samples/cpp/tutorial_code/ImgProc/Smoothing.cpp
diff --git a/samples/cpp/tutorial_code/ImgProc/Threshold.cpp b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp
new file mode 100644
index 0000000000..c224ee5d5d
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp
@@ -0,0 +1,84 @@
+/**
+ * @file Threshold.cpp
+ * @brief Sample code that shows how to use the diverse threshold options offered by OpenCV
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global variables
+
+int threshold_value = 0;
+int threshold_type = 3;;
+int const max_value = 255;
+int const max_type = 4;
+int const max_BINARY_value = 255;
+
+Mat src, src_gray, dst;
+char* window_name = "Threshold Demo";
+
+char* trackbar_type = "Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted";
+char* trackbar_value = "Value";
+
+/// Function headers
+void Threshold_Demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load an image
+  src = imread( argv[1], 1 );
+
+  /// Convert the image to Gray
+  cvtColor( src, src_gray, CV_RGB2GRAY );
+
+  /// Create a window to display results
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Create Trackbar to choose type of Threshold
+  createTrackbar( trackbar_type, 
+		  window_name, &threshold_type, 
+		  max_type, Threshold_Demo );
+
+  createTrackbar( trackbar_value,
+		  window_name, &threshold_value,
+		  max_value, Threshold_Demo );
+
+  /// Call the function to initialize
+  Threshold_Demo( 0, 0 );
+
+  /// Wait until user finishes program
+  while(true)
+    {
+      int c;
+      c = waitKey( 20 );
+      if( (char)c == 27 )
+	{ break; }
+    }
+
+}
+
+
+/**
+ * @function Threshold_Demo
+ */
+void Threshold_Demo( int, void* )
+{
+  /* 0: Binary
+     1: Binary Inverted
+     2: Threshold Truncated
+     3: Threshold to Zero
+     4: Threshold to Zero Inverted
+   */
+
+  threshold( src_gray, dst, threshold_value, max_BINARY_value,threshold_type );
+
+  imshow( window_name, dst );
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp
new file mode 100644
index 0000000000..fd540614eb
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp
@@ -0,0 +1,76 @@
+/**
+ * @file CannyDetector_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Canny Detector
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global variables
+
+Mat src, src_gray;
+Mat dst, detected_edges;
+
+int edgeThresh = 1;
+int lowThreshold;
+int const max_lowThreshold = 100;
+int ratio = 3;
+int kernel_size = 3;
+char* window_name = "Edge Map";
+
+/**
+ * @function CannyThreshold
+ * @brief Trackbar callback - Canny thresholds input with a ratio 1:3
+ */
+void CannyThreshold(int, void*)
+{
+    /// Reduce noise with a kernel 3x3
+    blur( src_gray, detected_edges, Size(3,3) );
+
+    /// Canny detector
+    Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio, kernel_size );
+
+    /// Using Canny's output as a mask, we display our result
+    dst = Scalar::all(0);
+    
+    src.copyTo( dst, detected_edges);
+    imshow( window_name, dst );
+}
+
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load an image
+  src = imread( argv[1] );
+
+  if( !src.data )
+    { return -1; }
+
+  /// Create a matrix of the same type and size as src (for dst)
+  dst.create( src.size(), src.type() );
+
+  /// Convert the image to grayscale
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+
+  /// Create a window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Create a Trackbar for user to enter threshold
+  createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );
+
+  /// Show the image
+  CannyThreshold(0, 0);
+
+  /// Wait until user exit program by pressing a key
+  waitKey(0);
+
+  return 0;
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp
new file mode 100644
index 0000000000..159d3a4d3b
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp
@@ -0,0 +1,81 @@
+/**
+ * @function Geometric_Transforms_Demo.cpp
+ * @brief Demo code for Geometric Transforms
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+char* source_window = "Source image";
+char* warp_window = "Warp";
+char* warp_rotate_window = "Warp + Rotate";
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  Point2f srcTri[3];
+  Point2f dstTri[3];
+
+  Mat rot_mat( 2, 3, CV_32FC1 );
+  Mat warp_mat( 2, 3, CV_32FC1 );
+  Mat src, warp_dst, warp_rotate_dst;
+
+  /// Load the image
+  src = imread( argv[1], 1 );
+
+  /// Set the dst image the same type and size as src  
+  warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
+
+  /// Set your 3 points to calculate the  Affine Transform
+  srcTri[0] = Point2f( 0,0 );
+  srcTri[1] = Point2f( src.cols - 1, 0 );
+  srcTri[2] = Point2f( 0, src.rows - 1 );
+  
+  dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );
+  dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );
+  dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );
+
+  /// Get the Affine Transform
+  warp_mat = getAffineTransform( srcTri, dstTri );
+
+  /// Apply the Affine Transform just found to the src image
+  warpAffine( src, warp_dst, warp_mat, warp_dst.size() );
+
+  /** Rotating the image after Warp */
+
+  /// Compute a rotation matrix with respect to the center of the image
+  Point center = Point( warp_dst.cols/2, warp_dst.rows/2 );
+  double angle = -50.0;
+  double scale = 0.6;
+
+  /// Get the rotation matrix with the specifications above
+  rot_mat = getRotationMatrix2D( center, angle, scale );
+
+  /// Rotate the warped image
+  warpAffine( warp_dst, warp_rotate_dst, rot_mat, warp_dst.size() );
+  
+
+  /// Show what you got
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  namedWindow( warp_window, CV_WINDOW_AUTOSIZE );
+  imshow( warp_window, warp_dst );
+
+  namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );
+  imshow( warp_rotate_window, warp_rotate_dst );
+
+  /// Wait until user exits the program
+  waitKey(0);
+
+  return 0;
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
new file mode 100644
index 0000000000..efc061657d
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
@@ -0,0 +1,55 @@
+/**
+ * @file HoughCircle_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main(int argc, char** argv)
+{
+   Mat src, src_gray;
+
+   /// Read the image
+   src = imread( argv[1], 1 );
+
+   if( !src.data )
+     { return -1; }
+
+   /// Convert it to gray 
+    cvtColor( src, src_gray, CV_BGR2GRAY );
+
+   /// Reduce the noise so we avoid false circle detection
+    GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+
+    vector<Vec3f> circles;
+
+   /// Apply the Hough Transform to find the circles
+    HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows/8, 200, 100, 0, 0 );
+
+   /// Draw the circles detected
+    for( size_t i = 0; i < circles.size(); i++ )
+    {
+         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
+         int radius = cvRound(circles[i][2]);
+         // circle center
+         circle( src, center, 3, Scalar(0,255,0), -1, 8, 0 );
+         // circle outline
+         circle( src, center, radius, Scalar(0,0,255), 3, 8, 0 );
+    }
+
+   /// Show your results 
+    namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
+    imshow( "Hough Circle Transform Demo", src );
+
+    waitKey(0);
+    return 0;
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
new file mode 100644
index 0000000000..406030ff8a
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
@@ -0,0 +1,128 @@
+/**
+ * @file HoughLines_Demo.cpp
+ * @brief Demo code for Hough Transform
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+
+/** General variables */
+Mat src, edges; 
+Mat src_gray; 
+Mat standard_hough, probabilistic_hough;
+int min_threshold = 50;
+int max_trackbar = 150;
+
+char* standard_name = "Standard Hough Lines Demo";
+char* probabilistic_name = "Probabilistic Hough Lines Demo";
+
+int s_trackbar = max_trackbar;
+int p_trackbar = max_trackbar;
+
+/// Function Headers
+void help();
+void Standard_Hough( int, void* );
+void Probabilistic_Hough( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+   /// Read the image
+   src = imread( argv[1], 1 );
+
+   if( src.empty() )
+     { help();
+       return -1;
+     }
+
+   /// Pass the image to gray
+   cvtColor( src, src_gray, CV_RGB2GRAY );
+    		
+   /// Apply Canny edge detector
+   Canny( src_gray, edges, 50, 200, 3 );
+
+   /// Create Trackbars for Thresholds
+   char thresh_label[50];
+   sprintf( thresh_label, "Thres: %d + input", min_threshold );
+
+   namedWindow( standard_name, CV_WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough);
+
+   namedWindow( probabilistic_name, CV_WINDOW_AUTOSIZE );
+   createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough);
+
+   /// Initialize
+   Standard_Hough(0, 0);
+   Probabilistic_Hough(0, 0);
+   waitKey(0);
+   return 0;
+}
+
+/**
+ * @function help
+ * @brief Indications of how to run this program and why is it for
+ */
+void help()
+{
+  printf("\t Hough Transform to detect lines \n ");
+  printf("\t---------------------------------\n ");
+  printf(" Usage: ./HoughLines_Demo <image_name> \n");
+}
+
+/**
+ * @function Standard_Hough
+ */
+void Standard_Hough( int, void* )
+{
+  vector<Vec2f> s_lines;
+  cvtColor( edges, standard_hough, CV_GRAY2BGR );
+
+  /// 1. Use Standard Hough Transform
+  HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 ); 
+
+  /// Show the result
+  for( int i = 0; i < s_lines.size(); i++ )
+     {
+      float r = s_lines[i][0], t = s_lines[i][1];
+      double cos_t = cos(t), sin_t = sin(t);
+      double x0 = r*cos_t, y0 = r*sin_t;
+      double alpha = 1000;
+
+       Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
+       Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
+       line( standard_hough, pt1, pt2, Scalar(255,0,0), 3, CV_AA); 
+     } 
+
+   imshow( standard_name, standard_hough );
+}
+
+/**
+ * @function Probabilistic_Hough
+ */
+void Probabilistic_Hough( int, void* )
+{
+  vector<Vec4i> p_lines;
+  cvtColor( edges, probabilistic_hough, CV_GRAY2BGR );
+
+  /// 2. Use Probabilistic Hough Transform
+  HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );
+
+  /// Show the result
+  for( size_t i = 0; i < p_lines.size(); i++ )
+     {
+       Vec4i l = p_lines[i];
+       line( probabilistic_hough, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255,0,0), 3, CV_AA);
+     }
+
+   imshow( probabilistic_name, probabilistic_hough );
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp
new file mode 100644
index 0000000000..0893f279be
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp
@@ -0,0 +1,56 @@
+/**
+ * @file Laplace_Demo.cpp
+ * @brief Sample code showing how to detect edges using the Laplace operator
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+
+  Mat src, src_gray, dst;
+  int kernel_size = 3; 
+  int scale = 1;
+  int delta = 0;
+  int ddepth = CV_16S;
+  char* window_name = "Laplace Demo";
+
+  int c;
+
+  /// Load an image
+  src = imread( argv[1] );
+
+  if( !src.data )
+    { return -1; }
+
+  /// Remove noise by blurring with a Gaussian filter
+  GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
+
+  /// Convert the image to grayscale
+  cvtColor( src, src_gray, CV_RGB2GRAY );
+
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Apply Laplace function
+  Mat abs_dst;
+
+  Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
+  convertScaleAbs( dst, abs_dst );
+
+  /// Show what you got
+  imshow( window_name, abs_dst );
+
+  waitKey(0);
+
+  return 0;
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp
new file mode 100644
index 0000000000..6eb167913f
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp
@@ -0,0 +1,98 @@
+/**
+ * @function Remap_Demo.cpp
+ * @brief Demo code for Remap
+ * @author Ana Huaman
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global variables
+Mat src, dst;
+Mat map_x, map_y;
+char* remap_window = "Remap demo";
+int ind = 0;
+
+/// Function Headers
+void update_map( void );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load the image
+  src = imread( argv[1], 1 );
+
+  /// Create dst, map_x and map_y with the same size as src:
+  dst.create( src.size(), src.type() );
+  map_x.create( src.size(), CV_32FC1 );
+  map_y.create( src.size(), CV_32FC1 );
+  
+  /// Create window
+  namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
+
+  /// Loop
+  while( true )
+  {
+    /// Each 1 sec. Press ESC to exit the program
+    int c = waitKey( 1000 );
+
+    if( (char)c == 27 )
+      { break; }
+
+    /// Update map_x & map_y. Then apply remap
+    update_map();
+    remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) ); 
+
+    // Display results
+    imshow( remap_window, dst );
+  }
+  return 0;
+}
+
+/**
+ * @function update_map
+ * @brief Fill the map_x and map_y matrices with 4 types of mappings
+ */
+void update_map( void )
+{
+  ind = ind%4;
+
+  for( int j = 0; j < src.rows; j++ )
+    { for( int i = 0; i < src.cols; i++ )
+ 	 {
+           switch( ind )
+	     {   
+	     case 0:
+	       if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )
+                 {
+	           map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;
+	           map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;
+	          }
+	       else
+		 { map_x.at<float>(j,i) = 0 ;
+	           map_y.at<float>(j,i) = 0 ;
+                 }
+                   break;
+	     case 1:
+	           map_x.at<float>(j,i) = i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+             case 2:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = j ;
+		   break;
+             case 3:
+	           map_x.at<float>(j,i) = src.cols - i ;
+	           map_y.at<float>(j,i) = src.rows - j ;
+		   break;
+             } // end of switch
+	 }
+    }
+  ind++;
+}
diff --git a/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
new file mode 100644
index 0000000000..0d161ce9dd
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
@@ -0,0 +1,67 @@
+/**
+ * @file Sobel_Demo.cpp
+ * @brief Sample code using Sobel and/orScharr OpenCV functions to make a simple Edge Detector
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+
+  Mat src, src_gray;
+  Mat grad; 
+  char* window_name = "Sobel Demo - Simple Edge Detector";
+  int scale = 1;
+  int delta = 0;
+  int ddepth = CV_16S;
+
+  int c;
+
+  /// Load an image
+  src = imread( argv[1] );
+
+  if( !src.data )
+    { return -1; }
+
+  GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
+
+  /// Convert it to gray
+  cvtColor( src, src_gray, CV_RGB2GRAY );
+
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Generate grad_x and grad_y
+  Mat grad_x, grad_y;
+  Mat abs_grad_x, abs_grad_y;
+ 
+  /// Gradient X
+  //Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
+  Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );   
+  convertScaleAbs( grad_x, abs_grad_x );
+
+  /// Gradient Y  
+  //Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
+  Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );   
+  convertScaleAbs( grad_y, abs_grad_y );
+
+  /// Total Gradient (approximate)
+  addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
+
+  imshow( window_name, grad );
+
+  waitKey(0);
+
+  return 0;
+}
+
+
diff --git a/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp b/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
new file mode 100644
index 0000000000..2124f67604
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
@@ -0,0 +1,75 @@
+/**
+ * @file copyMakeBorder_demo.cpp
+ * @brief Sample code that shows the functionality of copyMakeBorder
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/// Global Variables 
+Mat src, dst;
+int top, bottom, left, right;
+int borderType;
+Scalar value;
+char* window_name = "copyMakeBorder Demo";
+RNG rng(12345);
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+
+  int c;
+
+  /// Load an image
+  src = imread( argv[1] );
+  
+  if( !src.data )
+    { return -1;
+      printf(" No data entered, please enter the path to an image file \n"); 
+    }
+
+  /// Brief how-to for this program
+  printf( "\n \t copyMakeBorder Demo: \n" );
+  printf( "\t -------------------- \n" );
+  printf( " ** Press 'c' to set the border to a random constant value \n");
+  printf( " ** Press 'r' to set the border to be replicated \n");
+  printf( " ** Press 'ESC' to exit the program \n");
+
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+
+  /// Initialize arguments for the filter
+  top = (int) (0.05*src.rows); bottom = (int) (0.05*src.rows); 
+  left = (int) (0.05*src.cols); right = (int) (0.05*src.cols);
+  dst = src;
+
+  imshow( window_name, dst );
+  
+  while( true )
+       {
+         c = waitKey(500);
+
+         if( (char)c == 27 )
+           { break; }
+         else if( (char)c == 'c' )
+           { borderType = BORDER_CONSTANT; }
+         else if( (char)c == 'r' )
+           { borderType = BORDER_REPLICATE; }
+
+         value = Scalar( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) );
+         copyMakeBorder( src, dst, top, bottom, left, right, borderType, value );
+
+         imshow( window_name, dst );
+       }
+
+  return 0;
+}
+
+
diff --git a/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp b/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp
new file mode 100644
index 0000000000..c5be0e7938
--- /dev/null
+++ b/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp
@@ -0,0 +1,65 @@
+/**
+ * @file filter2D_demo.cpp
+ * @brief Sample code that shows how to implement your own linear filters by using filter2D function
+ * @author OpenCV team
+ */
+
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <stdlib.h>
+#include <stdio.h>
+
+using namespace cv;
+
+/**
+ * @function main
+ */
+int main ( int argc, char** argv )
+{
+  /// Declare variables
+  Mat src, dst;
+
+  Mat kernel;
+  Point anchor;
+  double delta;
+  int ddepth;  
+  int kernel_size;
+  char* window_name = "filter2D Demo";
+
+  int c;
+
+  /// Load an image
+  src = imread( argv[1] );
+
+  if( !src.data )
+    { return -1; }
+
+  /// Create window
+  namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+  
+  /// Initialize arguments for the filter
+  anchor = Point( -1, -1 );
+  delta = 0;
+  ddepth = -1;
+
+  /// Loop - Will filter the image with different kernel sizes each 0.5 seconds
+  int ind = 0;
+  while( true )
+       {
+         c = waitKey(500);
+         /// Press 'ESC' to exit the program
+         if( (char)c == 27 )
+           { break; }
+
+         /// Update kernel size for a normalized box filter
+         kernel_size = 3 + 2*( ind%5 );
+         kernel = Mat::ones( kernel_size, kernel_size, CV_32F )/ (float)(kernel_size*kernel_size);
+
+         /// Apply filter
+         filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );
+         imshow( window_name, dst );
+         ind++;
+       }
+  
+  return 0;
+}
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp
new file mode 100644
index 0000000000..60048ff2f0
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp
@@ -0,0 +1,73 @@
+/**
+ * @function findContours_Demo.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+Mat src; Mat src_gray;
+int thresh = 100;
+int max_thresh = 255;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+
+  /// Convert image to gray and blur it
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+  blur( src_gray, src_gray, Size(3,3) );
+
+  /// Create Window
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
+  thresh_callback( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+  Mat canny_output;
+  vector<vector<Point> > contours;
+  vector<Vec4i> hierarchy;
+
+  /// Detect edges using canny
+  Canny( src_gray, canny_output, thresh, thresh*2, 3 );
+  /// Find contours  
+  findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+  /// Draw contours
+  Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+  for( int i = 0; i< contours.size(); i++ )
+     { 
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+     }
+
+  /// Show in a window
+  namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+  imshow( "Contours", drawing );
+}
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp
new file mode 100644
index 0000000000..c701691b86
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp
@@ -0,0 +1,88 @@
+/**
+ * @function generalContours_demo1.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+Mat src; Mat src_gray;
+int thresh = 100;
+int max_thresh = 255;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+
+  /// Convert image to gray and blur it
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+  blur( src_gray, src_gray, Size(3,3) );
+
+  /// Create Window
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+  thresh_callback( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+  Mat threshold_output;
+  vector<vector<Point> > contours;
+  vector<Vec4i> hierarchy;
+
+  /// Detect edges using Threshold
+  threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+  /// Find contours  
+  findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+  /// Approximate contours to polygons + get bounding rects and circles
+  vector<vector<Point> > contours_poly( contours.size() );
+  vector<Rect> boundRect( contours.size() );
+  vector<Point2f>center( contours.size() );
+  vector<float>radius( contours.size() );
+
+  for( int i = 0; i < contours.size(); i++ )
+     { approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true ); 
+       boundRect[i] = boundingRect( Mat(contours_poly[i]) ); 
+       minEnclosingCircle( contours_poly[i], center[i], radius[i] );
+     } 
+
+
+  /// Draw polygonal contour + bonding rects + circles
+  Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+  for( int i = 0; i< contours.size(); i++ )
+     { 
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       drawContours( drawing, contours_poly, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+       rectangle( drawing, boundRect[i].tl(), boundRect[i].br(), color, 2, 8, 0 );
+       circle( drawing, center[i], (int)radius[i], color, 2, 8, 0 );
+     }
+
+  /// Show in a window
+  namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+  imshow( "Contours", drawing );
+}
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp
new file mode 100644
index 0000000000..4a2aeec0fd
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp
@@ -0,0 +1,90 @@
+/**
+ * @function generalContours_demo2.cpp
+ * @brief Demo code to obtain ellipses and rotated rectangles that contain detected contours
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+Mat src; Mat src_gray;
+int thresh = 100;
+int max_thresh = 255;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+
+  /// Convert image to gray and blur it
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+  blur( src_gray, src_gray, Size(3,3) );
+
+  /// Create Window
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+  thresh_callback( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+  Mat threshold_output;
+  vector<vector<Point> > contours;
+  vector<Vec4i> hierarchy;
+
+  /// Detect edges using Threshold
+  threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+  /// Find contours  
+  findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+  /// Find the rotated rectangles and ellipses for each contour
+  vector<RotatedRect> minRect( contours.size() );
+  vector<RotatedRect> minEllipse( contours.size() );
+
+  for( int i = 0; i < contours.size(); i++ )
+     { minRect[i] = minAreaRect( Mat(contours[i]) ); 
+       if( contours[i].size() > 5 )
+         { minEllipse[i] = fitEllipse( Mat(contours[i]) ); }
+     } 
+
+  /// Draw contours + rotated rects + ellipses
+  Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+  for( int i = 0; i< contours.size(); i++ )
+     { 
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       // contour
+       drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+       // ellipse
+       ellipse( drawing, minEllipse[i], color, 2, 8 );
+       // rotated rectangle        
+       Point2f rect_points[4]; minRect[i].points( rect_points );
+       for( int j = 0; j < 4; j++ )
+          line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 ); 
+     }
+
+  /// Show in a window
+  namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+  imshow( "Contours", drawing );
+}
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp
new file mode 100644
index 0000000000..1fd5e5be8b
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp
@@ -0,0 +1,81 @@
+/**
+ * @function hull_demo.cpp
+ * @brief Demo code to find contours in an image
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+Mat src; Mat src_gray;
+int thresh = 100;
+int max_thresh = 255;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+
+  /// Convert image to gray and blur it
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+  blur( src_gray, src_gray, Size(3,3) );
+
+  /// Create Window
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
+  thresh_callback( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+  Mat src_copy = src.clone();
+  Mat threshold_output;
+  vector<vector<Point> > contours;
+  vector<Vec4i> hierarchy;
+
+  /// Detect edges using Threshold
+  threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );
+
+  /// Find contours  
+  findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+  /// Find the convex hull object for each contour
+ vector<vector<Point> >hull( contours.size() );
+  for( int i = 0; i < contours.size(); i++ )
+     {   convexHull( Mat(contours[i]), hull[i], false ); } 
+
+  /// Draw contours + hull results
+  Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
+  for( int i = 0; i< contours.size(); i++ )
+     { 
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); 
+       drawContours( drawing, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point() );       
+     }
+
+  /// Show in a window
+  namedWindow( "Hull demo", CV_WINDOW_AUTOSIZE );
+  imshow( "Hull demo", drawing );
+}
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp
new file mode 100644
index 0000000000..e83b6094e5
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp
@@ -0,0 +1,95 @@
+/**
+ * @function moments_demo.cpp
+ * @brief Demo code to calculate moments
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+Mat src; Mat src_gray;
+int thresh = 100;
+int max_thresh = 255;
+RNG rng(12345);
+
+/// Function header
+void thresh_callback(int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+
+  /// Convert image to gray and blur it
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+  blur( src_gray, src_gray, Size(3,3) );
+
+  /// Create Window
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+
+  createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
+  thresh_callback( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function thresh_callback
+ */
+void thresh_callback(int, void* )
+{
+  Mat canny_output;
+  vector<vector<Point> > contours;
+  vector<Vec4i> hierarchy;
+
+  /// Detect edges using canny
+  Canny( src_gray, canny_output, thresh, thresh*2, 3 );
+  /// Find contours  
+  findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
+
+  /// Get the moments
+  vector<Moments> mu(contours.size() );
+  for( int i = 0; i < contours.size(); i++ )
+     { mu[i] = moments( contours[i], false ); }
+
+  ///  Get the mass centers: 
+  vector<Point2f> mc( contours.size() );
+  for( int i = 0; i < contours.size(); i++ )
+     { mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }
+
+  /// Draw contours
+  Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
+  for( int i = 0; i< contours.size(); i++ )
+     { 
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+       circle( drawing, mc[i], 4, color, -1, 8, 0 );
+     }
+
+  /// Show in a window
+  namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+  imshow( "Contours", drawing );
+
+  /// Calculate the area with the moments 00 and compare with the result of the OpenCV function
+  printf("\t Info: Area and Contour Length \n");
+  for( int i = 0; i< contours.size(); i++ )
+     {
+       printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );  
+       Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
+       drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() ); 
+       circle( drawing, mc[i], 4, color, -1, 8, 0 );
+     }
+}
+
diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp
new file mode 100644
index 0000000000..08f0eac534
--- /dev/null
+++ b/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp
@@ -0,0 +1,83 @@
+/**
+ * @function pointPolygonTest_demo.cpp
+ * @brief Demo code to use the pointPolygonTest function...fairly easy
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Create an image
+  const int r = 100;
+  Mat src = Mat::zeros( Size( 4*r, 4*r ), CV_8UC1 );
+
+  /// Create a sequence of points to make a contour:
+  vector<Point2f> vert(6);
+
+  vert[0] = Point( 1.5*r, 1.34*r );
+  vert[1] = Point( 1*r, 2*r );
+  vert[2] = Point( 1.5*r, 2.866*r );
+  vert[3] = Point( 2.5*r, 2.866*r );
+  vert[4] = Point( 3*r, 2*r );
+  vert[5] = Point( 2.5*r, 1.34*r );
+
+  /// Draw it in src
+  for( int j = 0; j < 6; j++ )
+     { line( src, vert[j],  vert[(j+1)%6], Scalar( 255 ), 3, 8 ); } 
+
+  /// Get the contours
+  vector<vector<Point> > contours; vector<Vec4i> hierarchy;
+  Mat src_copy = src.clone();
+
+  findContours( src_copy, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);  
+
+  /// Calculate the distances to the contour
+  Mat raw_dist( src.size(), CV_32FC1 );
+
+  for( int j = 0; j < src.rows; j++ )
+     { for( int i = 0; i < src.cols; i++ )
+          { raw_dist.at<float>(j,i) = pointPolygonTest( contours[0], Point2f(i,j), true ); }
+     }
+
+  double minVal; double maxVal;
+  minMaxLoc( raw_dist, &minVal, &maxVal, 0, 0, Mat() );
+  minVal = abs(minVal); maxVal = abs(maxVal);
+  
+  /// Depicting the  distances graphically
+  Mat drawing = Mat::zeros( src.size(), CV_8UC3 );
+
+  for( int j = 0; j < src.rows; j++ )
+     { for( int i = 0; i < src.cols; i++ )
+          { 
+            if( raw_dist.at<float>(j,i) < 0 )
+              { drawing.at<Vec3b>(j,i)[0] = 255 - (int) abs(raw_dist.at<float>(j,i))*255/minVal; }
+            else if( raw_dist.at<float>(j,i) > 0 )
+              { drawing.at<Vec3b>(j,i)[2] = 255 - (int) raw_dist.at<float>(j,i)*255/maxVal; }    
+            else
+              { drawing.at<Vec3b>(j,i)[0] = 255; drawing.at<Vec3b>(j,i)[1] = 255; drawing.at<Vec3b>(j,i)[2] = 255; }     
+          }
+     }
+
+  /// Create Window and show your results
+  char* source_window = "Source";
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, src );
+  namedWindow( "Distance", CV_WINDOW_AUTOSIZE );
+  imshow( "Distance", drawing );
+
+  waitKey(0);
+  return(0);
+}
+
+
diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
new file mode 100644
index 0000000000..42fd7a0036
--- /dev/null
+++ b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
@@ -0,0 +1,123 @@
+/**
+ * @function cornerDetector_Demo.cpp
+ * @brief Demo code for detecting corners using OpenCV built-in functions
+ * @author OpenCV team
+ */
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+Mat myHarris_dst; Mat myHarris_copy; Mat Mc;
+Mat myShiTomasi_dst; Mat myShiTomasi_copy; 
+
+int myShiTomasi_qualityLevel = 50;
+int myHarris_qualityLevel = 50;
+int max_qualityLevel = 100;
+
+double myHarris_minVal; double myHarris_maxVal;
+double myShiTomasi_minVal; double myShiTomasi_maxVal;
+
+RNG rng(12345);
+
+char* myHarris_window = "My Harris corner detector";
+char* myShiTomasi_window = "My Shi Tomasi corner detector";
+
+/// Function headers
+void myShiTomasi_function( int, void* );
+void myHarris_function( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+
+  /// Set some parameters
+  int blockSize = 3; int apertureSize = 3;
+
+  /// My Harris matrix -- Using cornerEigenValsAndVecs
+  myHarris_dst = Mat::zeros( src_gray.size(), CV_32FC(6) );
+  Mc = Mat::zeros( src_gray.size(), CV_32FC1 );
+
+  cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize, BORDER_DEFAULT );
+
+  /* calculate Mc */ 
+  for( int j = 0; j < src_gray.rows; j++ )
+     { for( int i = 0; i < src_gray.cols; i++ )
+          {
+            float lambda_1 = myHarris_dst.at<float>( j, i, 0 );
+            float lambda_2 = myHarris_dst.at<float>( j, i, 1 );
+            Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 );
+          }
+     }
+
+  minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal, 0, 0, Mat() );
+  
+  /* Create Window and Trackbar */
+  namedWindow( myHarris_window, CV_WINDOW_AUTOSIZE );
+  createTrackbar( " Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );  
+  myHarris_function( 0, 0 );
+
+  /// My Shi-Tomasi -- Using cornerMinEigenVal
+  myShiTomasi_dst = Mat::zeros( src_gray.size(), CV_32FC1 );  
+  cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize, BORDER_DEFAULT );
+
+  minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal, 0, 0, Mat() );
+
+  /* Create Window and Trackbar */
+  namedWindow( myShiTomasi_window, CV_WINDOW_AUTOSIZE );   
+  createTrackbar( " Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );  
+  myShiTomasi_function( 0, 0 );
+  
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function myShiTomasi_function
+ */
+void myShiTomasi_function( int, void* )
+{
+  myShiTomasi_copy = src.clone();
+
+  if( myShiTomasi_qualityLevel < 1 ) { myShiTomasi_qualityLevel = 1; }
+
+  for( int j = 0; j < src_gray.rows; j++ )
+     { for( int i = 0; i < src_gray.cols; i++ )
+          {
+            if( myShiTomasi_dst.at<float>(j,i) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
+              { circle( myShiTomasi_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); }
+          }
+     }
+  imshow( myShiTomasi_window, myShiTomasi_copy );
+}
+
+/**
+ * @function myHarris_function
+ */
+void myHarris_function( int, void* )
+{
+  myHarris_copy = src.clone();
+
+  if( myHarris_qualityLevel < 1 ) { myHarris_qualityLevel = 1; }
+
+  for( int j = 0; j < src_gray.rows; j++ )
+     { for( int i = 0; i < src_gray.cols; i++ )
+          {
+            if( Mc.at<float>(j,i) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel )
+              { circle( myHarris_copy, Point(i,j), 4, Scalar( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); }
+          }
+     }
+  imshow( myHarris_window, myHarris_copy );
+}
+
diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp
new file mode 100644
index 0000000000..6bf3cacd01
--- /dev/null
+++ b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp
@@ -0,0 +1,82 @@
+/**
+ * @function cornerHarris_Demo.cpp
+ * @brief Demo code for detecting corners using Harris-Stephens method
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+int thresh = 200;
+int max_thresh = 255;
+
+char* source_window = "Source image";
+char* corners_window = "Corners detected";
+
+/// Function header
+void cornerHarris_demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+
+  /// Create a window and a trackbar
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
+  imshow( source_window, src );
+  
+  cornerHarris_demo( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function cornerHarris_demo
+ * @brief Executes the corner detection and draw a circle around the possible corners
+ */
+void cornerHarris_demo( int, void* )
+{
+
+  Mat dst, dst_norm, dst_norm_scaled;
+  dst = Mat::zeros( src.size(), CV_32FC1 );
+
+  /// Detector parameters
+  int blockSize = 2;
+  int apertureSize = 3;
+  double k = 0.04;
+ 
+  /// Detecting corners
+  cornerHarris( src_gray, dst, blockSize, apertureSize, k, BORDER_DEFAULT );
+
+  /// Normalizing
+  normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() );
+  convertScaleAbs( dst_norm, dst_norm_scaled ); 
+
+  /// Drawing a circle around corners
+  for( int j = 0; j < dst_norm.rows ; j++ )
+     { for( int i = 0; i < dst_norm.cols; i++ )
+          {
+            if( (int) dst_norm.at<float>(j,i) > thresh )
+              { 
+               circle( dst_norm_scaled, Point( i, j ), 5,  Scalar(0), 2, 8, 0 ); 
+              }
+          } 
+     }    
+  /// Showing the result 
+  namedWindow( corners_window, CV_WINDOW_AUTOSIZE );
+  imshow( corners_window, dst_norm_scaled );
+}
diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp
new file mode 100644
index 0000000000..0e6ef5551b
--- /dev/null
+++ b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp
@@ -0,0 +1,105 @@
+/**
+ * @function cornerSubPix_Demo.cpp
+ * @brief Demo code for refining corner locations
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+
+int maxCorners = 10;
+int maxTrackbar = 25;
+
+RNG rng(12345);
+char* source_window = "Image";
+
+/// Function header
+void goodFeaturesToTrack_Demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+
+  /// Create Window
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+  /// Create Trackbar to set the number of corners
+  createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  
+
+  imshow( source_window, src );
+
+  goodFeaturesToTrack_Demo( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Apply Shi-Tomasi corner detector
+ */
+void goodFeaturesToTrack_Demo( int, void* )
+{
+  if( maxCorners < 1 ) { maxCorners = 1; }
+  
+  /// Parameters for Shi-Tomasi algorithm
+  vector<Point2f> corners;
+  double qualityLevel = 0.01;
+  double minDistance = 10;
+  int blockSize = 3;
+  bool useHarrisDetector = false;
+  double k = 0.04;
+
+  /// Copy the source image
+  Mat copy;
+  copy = src.clone();
+
+  /// Apply corner detection
+  goodFeaturesToTrack( src_gray, 
+		       corners,
+		       maxCorners,
+		       qualityLevel,
+		       minDistance,
+		       Mat(),
+		       blockSize,
+		       useHarrisDetector,
+		       k );
+  
+
+  /// Draw corners detected
+  cout<<"** Number of corners detected: "<<corners.size()<<endl;
+  int r = 4;
+  for( int i = 0; i < corners.size(); i++ )
+     { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
+
+  /// Show what you got
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, copy );  
+
+  /// Set the neeed parameters to find the refined corners
+  Size winSize = Size( 5, 5 );
+  Size zeroZone = Size( -1, -1 );
+  TermCriteria criteria = TermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 40, 0.001 );
+
+  /// Calculate the refined corner locations
+  cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
+
+  /// Write them down
+  for( int i = 0; i < corners.size(); i++ )
+     { cout<<" -- Refined Corner ["<<i<<"]  ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }	
+}
+
diff --git a/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp
new file mode 100644
index 0000000000..247d678098
--- /dev/null
+++ b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp
@@ -0,0 +1,93 @@
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Demo code for detecting corners using Shi-Tomasi method
+ * @author OpenCV team
+ */
+
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace cv;
+using namespace std;
+
+/// Global variables
+Mat src, src_gray;
+
+int maxCorners = 23;
+int maxTrackbar = 100;
+
+RNG rng(12345);
+char* source_window = "Image";
+
+/// Function header
+void goodFeaturesToTrack_Demo( int, void* );
+
+/**
+ * @function main
+ */
+int main( int argc, char** argv )
+{
+  /// Load source image and convert it to gray
+  src = imread( argv[1], 1 );
+  cvtColor( src, src_gray, CV_BGR2GRAY );
+
+  /// Create Window
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+
+  /// Create Trackbar to set the number of corners
+  createTrackbar( "Max  corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  
+
+  imshow( source_window, src );
+
+  goodFeaturesToTrack_Demo( 0, 0 );
+
+  waitKey(0);
+  return(0);
+}
+
+/**
+ * @function goodFeaturesToTrack_Demo.cpp
+ * @brief Apply Shi-Tomasi corner detector
+ */
+void goodFeaturesToTrack_Demo( int, void* )
+{
+  if( maxCorners < 1 ) { maxCorners = 1; }
+  
+  /// Parameters for Shi-Tomasi algorithm
+  vector<Point2f> corners;
+  double qualityLevel = 0.01;
+  double minDistance = 10;
+  int blockSize = 3;
+  bool useHarrisDetector = false;
+  double k = 0.04;
+
+  /// Copy the source image
+  Mat copy;
+  copy = src.clone();
+
+  /// Apply corner detection
+  goodFeaturesToTrack( src_gray, 
+		       corners,
+		       maxCorners,
+		       qualityLevel,
+		       minDistance,
+		       Mat(),
+		       blockSize,
+		       useHarrisDetector,
+		       k );
+  
+
+  /// Draw corners detected
+  cout<<"** Number of corners detected: "<<corners.size()<<endl;
+  int r = 4;
+  for( int i = 0; i < corners.size(); i++ )
+     { circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
+
+  /// Show what you got
+  namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+  imshow( source_window, copy );  
+}
+
diff --git a/samples/cpp/tutorial_code/Basic/Drawing_1.cpp b/samples/cpp/tutorial_code/core/Matrix/Drawing_1.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/Drawing_1.cpp
rename to samples/cpp/tutorial_code/core/Matrix/Drawing_1.cpp
diff --git a/samples/cpp/tutorial_code/Basic/Drawing_2.cpp b/samples/cpp/tutorial_code/core/Matrix/Drawing_2.cpp
similarity index 100%
rename from samples/cpp/tutorial_code/Basic/Drawing_2.cpp
rename to samples/cpp/tutorial_code/core/Matrix/Drawing_2.cpp
diff --git a/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
new file mode 100644
index 0000000000..628b974032
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
@@ -0,0 +1,78 @@
+#include "opencv2/core/core.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+void help(char* progName)
+{
+    cout << endl 
+        <<  "This program demonstrated the use of the discrete Fourier transform (DFT). " << endl
+        <<  "The dft of an image is taken and it's power spectrum is displayed."          << endl
+        <<  "Usage:"                                                                      << endl
+        << progName << " [image_name -- default lena.jpg] "                       << endl << endl;
+}
+
+int main(int argc, char ** argv)
+{
+	help(argv[0]);
+
+    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+
+    Mat I = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);
+    if( I.empty())
+        return -1;
+    
+    Mat padded;                            //expand input image to optimal size
+    int m = getOptimalDFTSize( I.rows );
+    int n = getOptimalDFTSize( I.cols ); // on the border add zero values
+    copyMakeBorder(I, padded, 0, m - I.rows, 0, n - I.cols, BORDER_CONSTANT, Scalar::all(0));
+
+    Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
+    Mat complexI;
+    merge(planes, 2, complexI);         // Add to the expanded another plane with zeros
+
+    dft(complexI, complexI);            // this way the result may fit in the source matrix
+
+    // compute the magnitude and switch to logarithmic scale
+    // => log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
+    split(complexI, planes);                   // planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
+    magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude  
+    Mat magI = planes[0];
+    
+    magI += Scalar::all(1);                    // switch to logarithmic scale
+    log(magI, magI);
+
+    // crop the spectrum, if it has an odd number of rows or columns
+    magI = magI(Rect(0, 0, magI.cols & -2, magI.rows & -2));
+
+    // rearrange the quadrants of Fourier image  so that the origin is at the image center        
+    int cx = magI.cols/2;
+    int cy = magI.rows/2;
+
+    Mat q0(magI, Rect(0, 0, cx, cy));   // Top-Left - Create a ROI per quadrant 
+    Mat q1(magI, Rect(cx, 0, cx, cy));  // Top-Right
+    Mat q2(magI, Rect(0, cy, cx, cy));  // Bottom-Left
+    Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right
+
+    Mat tmp;                           // swap quadrants (Top-Left with Bottom-Right)
+    q0.copyTo(tmp);
+    q3.copyTo(q0);
+    tmp.copyTo(q3);
+
+    q1.copyTo(tmp);                    // swap quadrant (Top-Right with Bottom-Left)
+    q2.copyTo(q1);
+    tmp.copyTo(q2);
+
+    normalize(magI, magI, 0, 1, CV_MINMAX); // Transform the matrix with float values into a 
+                                            // viewable image form (float between values 0 and 1).
+
+    imshow("Input Image"       , I   );    // Show the result
+    imshow("spectrum magnitude", magI);    
+    waitKey();
+
+    return 0;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
new file mode 100644
index 0000000000..eedf3f47b1
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
@@ -0,0 +1,154 @@
+#include <opencv2/core/core.hpp>
+#include <iostream>
+#include <string>
+
+using namespace cv;
+using namespace std;
+
+void help(char** av)
+{
+    cout << endl 
+        << av[0] << " shows the usage of the OpenCV serialization functionality."         << endl
+        << "usage: "                                                                      << endl
+        <<  av[0] << " outputfile.yml.gz"                                                 << endl
+        << "The output file may be either XML (xml) or YAML (yml/yaml). You can even compress it by "
+        << "specifying this in its extension like xml.gz yaml.gz etc... "                  << endl
+        << "With FileStorage you can serialize objects in OpenCV by using the << and >> operators" << endl
+        << "For example: - create a class and have it serialized"                         << endl
+        << "             - use it to read and write matrices."                            << endl;
+}
+
+class MyData
+{
+public:
+    MyData() : A(0), X(0), id()
+    {}
+    explicit MyData(int) : A(97), X(CV_PI), id("mydata1234") // explicit to avoid implicit conversion
+    {}
+    void write(FileStorage& fs) const                        //Write serialization for this class
+    {
+        fs << "{" << "A" << A << "X" << X << "id" << id << "}";
+    }
+    void read(const FileNode& node)                          //Read serialization for this class
+    {
+        A = (int)node["A"];
+        X = (double)node["X"];
+        id = (string)node["id"];
+    }
+public:   // Data Members
+    int A;
+    double X;
+    string id;
+};
+
+//These write and read functions must be defined for the serialization in FileStorage to work
+void write(FileStorage& fs, const std::string&, const MyData& x)
+{
+    x.write(fs);
+}
+void read(const FileNode& node, MyData& x, const MyData& default_value = MyData()){
+    if(node.empty())
+        x = default_value;
+    else
+        x.read(node);
+}
+
+// This function will print our custom class to the console
+ostream& operator<<(ostream& out, const MyData& m) 
+{ 
+    out << "{ id = " << m.id << ", ";
+    out << "X = " << m.X << ", ";
+    out << "A = " << m.A << "}";
+    return out;
+}
+
+int main(int ac, char** av)
+{
+    if (ac != 2)
+    {
+        help(av);
+        return 1;
+    }
+
+    string filename = av[1];
+    { //write
+        Mat R = Mat_<uchar>::eye(3, 3),
+            T = Mat_<double>::zeros(3, 1);
+        MyData m(1);
+
+        FileStorage fs(filename, FileStorage::WRITE);
+
+        fs << "iterationNr" << 100;
+        fs << "strings" << "[";                              // text - string sequence
+        fs << "image1.jpg" << "Awesomeness" << "baboon.jpg";
+        fs << "]";                                           // close sequence
+        
+        fs << "Mapping";                              // text - mapping
+        fs << "{" << "One" << 1;
+        fs <<        "Two" << 2 << "}";               
+
+        fs << "R" << R;                                      // cv::Mat
+        fs << "T" << T;
+
+        fs << "MyData" << m;                                // your own data structures
+
+        fs.release();                                       // explicit close
+        cout << "Write Done." << endl;
+    }
+
+    {//read
+        cout << endl << "Reading: " << endl;
+        FileStorage fs; 
+        fs.open(filename, FileStorage::READ);
+
+        int itNr; 
+        //fs["iterationNr"] >> itNr;
+        itNr = (int) fs["iterationNr"];
+        cout << itNr;
+        if (!fs.isOpened())
+        {
+            cerr << "Failed to open " << filename << endl;
+            help(av);
+            return 1;
+        }
+
+        FileNode n = fs["strings"];                         // Read string sequence - Get node
+        if (n.type() != FileNode::SEQ)
+        {
+            cerr << "strings is not a sequence! FAIL" << endl;
+            return 1;
+        }
+
+        FileNodeIterator it = n.begin(), it_end = n.end(); // Go through the node
+        for (; it != it_end; ++it)
+            cout << (string)*it << endl;
+        
+        
+        n = fs["Mapping"];                                // Read mappings from a sequence
+        cout << "Two  " << (int)(n["Two"]) << "; "; 
+        cout << "One  " << (int)(n["One"]) << endl << endl; 
+        
+
+        MyData m;
+        Mat R, T;
+
+        fs["R"] >> R;                                      // Read cv::Mat
+        fs["T"] >> T;
+        fs["MyData"] >> m;                                 // Read your own structure_
+
+        cout << endl 
+            << "R = " << R << endl;
+        cout << "T = " << T << endl << endl;
+        cout << "MyData = " << endl << m << endl << endl;
+
+        //Show default behavior for non existing nodes
+        cout << "Attempt to read NonExisting (should initialize the data structure with its default).";  
+        fs["NonExisting"] >> m;
+        cout << endl << "NonExisting = " << endl << m << endl;
+    }
+
+    cout << endl 
+        << "Tip: Open up " << filename << " with a text editor to see the serialized data." << endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp b/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
new file mode 100644
index 0000000000..bce6a5c092
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
@@ -0,0 +1,207 @@
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <iostream>
+#include <sstream>
+
+using namespace std; 
+using namespace cv;
+
+void help()
+{
+    cout
+        << "\n--------------------------------------------------------------------------" << endl
+        << "This program shows how to scan image objects in OpenCV (cv::Mat). As use case"
+        << " we take an input image and divide the native color palette (255) with the "  << endl
+        << "input. Shows C operator[] method, iterators and at function for on-the-fly item address calculation."<< endl
+        << "Usage:"                                                                       << endl
+        << "./howToScanImages imageNameToUse divideWith [G]"                              << endl
+        << "if you add a G parameter the image is processed in gray scale"                << endl
+        << "--------------------------------------------------------------------------"   << endl 
+        << endl;
+}
+
+Mat& ScanImageAndReduceC(Mat& I, const uchar* table);
+Mat& ScanImageAndReduceIterator(Mat& I, const uchar* table);
+Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar * table);
+
+int main( int argc, char* argv[])
+{
+    help(); 
+    if (argc < 3)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1; 
+    }
+
+    Mat I, J;
+    if( argc == 4 && !strcmp(argv[3],"G") )
+        I = imread(argv[1], CV_LOAD_IMAGE_GRAYSCALE);
+    else
+        I = imread(argv[1], CV_LOAD_IMAGE_COLOR);
+
+    if (!I.data)
+    {
+        cout << "The image" << argv[1] << " could not be loaded." << endl;
+        return -1;
+    }
+
+    int divideWith; // convert our input string to number - C++ style
+    stringstream s;
+    s << argv[2];
+    s >> divideWith;
+    if (!s)
+    {
+        cout << "Invalid number entered for dividing. " << endl; 
+        return -1;
+    }
+    
+    uchar table[256]; 
+    for (int i = 0; i < 256; ++i)
+       table[i] = divideWith* (i/divideWith);
+
+    const int times = 100; 
+    double t;
+
+    t = (double)getTickCount();    
+    
+    for (int i = 0; i < times; ++i)
+        J = ScanImageAndReduceC(I.clone(), table);
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the C operator [] (averaged for " 
+         << times << " runs): " << t << " milliseconds."<< endl;  
+
+    t = (double)getTickCount();    
+
+    for (int i = 0; i < times; ++i)
+        J = ScanImageAndReduceIterator(I.clone(), table);
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the iterator (averaged for " 
+        << times << " runs): " << t << " milliseconds."<< endl;  
+
+    t = (double)getTickCount();    
+
+    for (int i = 0; i < times; ++i)
+        ScanImageAndReduceRandomAccess(I.clone(), table);
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the on-the-fly address generation - at function (averaged for " 
+        << times << " runs): " << t << " milliseconds."<< endl;  
+
+    Mat lookUpTable(1, 256, CV_8U);
+    uchar* p = lookUpTable.data; 
+    for( int i = 0; i < 256; ++i)
+        p[i] = table[i];
+
+    t = (double)getTickCount();    
+    
+    for (int i = 0; i < times; ++i)
+        LUT(I, lookUpTable, J);
+
+    t = 1000*((double)getTickCount() - t)/getTickFrequency();
+    t /= times;
+
+    cout << "Time of reducing with the LUT function (averaged for " 
+        << times << " runs): " << t << " milliseconds."<< endl;  
+    return 0; 
+}
+
+Mat& ScanImageAndReduceC(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() != sizeof(uchar));     
+
+    int channels = I.channels();
+
+    int nRows = I.rows * channels; 
+    int nCols = I.cols;
+
+    if (I.isContinuous())
+    {
+        nCols *= nRows;
+        nRows = 1;         
+    }
+
+    int i,j;
+    uchar* p; 
+    for( i = 0; i < nRows; ++i)
+    {
+        p = I.ptr<uchar>(i);
+        for ( j = 0; j < nCols; ++j)
+        {
+            p[j] = table[p[j]];             
+        }
+    }
+    return I; 
+}
+
+Mat& ScanImageAndReduceIterator(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() != sizeof(uchar));     
+    
+    const int channels = I.channels();
+    switch(channels)
+    {
+    case 1: 
+        {
+            MatIterator_<uchar> it, end; 
+            for( it = I.begin<uchar>(), end = I.end<uchar>(); it != end; ++it)
+                *it = table[*it];
+            break;
+        }
+    case 3: 
+        {
+            MatIterator_<Vec3b> it, end; 
+            for( it = I.begin<Vec3b>(), end = I.end<Vec3b>(); it != end; ++it)
+            {
+                (*it)[0] = table[(*it)[0]];
+                (*it)[1] = table[(*it)[1]];
+                (*it)[2] = table[(*it)[2]];
+            }
+        }
+    }
+    
+    return I; 
+}
+
+Mat& ScanImageAndReduceRandomAccess(Mat& I, const uchar* const table)
+{
+    // accept only char type matrices
+    CV_Assert(I.depth() != sizeof(uchar));     
+
+    const int channels = I.channels();
+    switch(channels)
+    {
+    case 1: 
+        {
+            for( int i = 0; i < I.rows; ++i)
+                for( int j = 0; j < I.cols; ++j )
+                    I.at<uchar>(i,j) = table[I.at<uchar>(i,j)];
+            break;
+        }
+    case 3: 
+        {
+         Mat_<Vec3b> _I = I;
+            
+         for( int i = 0; i < I.rows; ++i)
+            for( int j = 0; j < I.cols; ++j )
+               {
+                   _I(i,j)[0] = table[_I(i,j)[0]];
+                   _I(i,j)[1] = table[_I(i,j)[1]];
+                   _I(i,j)[2] = table[_I(i,j)[2]];
+            }
+         I = _I;
+         break;
+        }
+    }
+    
+    return I;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
new file mode 100644
index 0000000000..5412b7b4ab
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
@@ -0,0 +1,134 @@
+#include <stdio.h>
+#include <iostream>
+
+#include <opencv2/core/core.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
+
+using namespace cv;  // The new C++ interface API is inside this namespace. Import it.
+using namespace std;
+
+void help( char* progName)
+{
+    cout << endl << progName 
+        << " shows how to use cv::Mat and IplImages together (converting back and forth)." << endl 
+        << "Also contains example for image read, spliting the planes, merging back and "  << endl 
+        << " color conversion, plus iterating through pixels. "                            << endl
+        << "Usage:" << endl
+        << progName << " [image-name Default: lena.jpg]"                           << endl << endl;
+}
+
+// comment out the define to use only the latest C++ API
+#define DEMO_MIXED_API_USE 
+
+int main( int argc, char** argv )
+{
+    help(argv[0]);
+    const char* imagename = argc > 1 ? argv[1] : "lena.jpg";
+
+#ifdef DEMO_MIXED_API_USE
+    Ptr<IplImage> IplI = cvLoadImage(imagename);      // Ptr<T> is safe ref-counting pointer class
+    if(IplI.empty())
+    {
+        cerr << "Can not load image " <<  imagename << endl;
+        return -1;
+    }
+    Mat I(IplI); // Convert to the new style container. Only header created. Image not copied.    
+#else
+    Mat I = imread(imagename);        // the newer cvLoadImage alternative, MATLAB-style function
+    if( I.empty() )                   // same as if( !I.data )
+    {
+        cerr << "Can not load image " <<  imagename << endl;
+        return -1;
+    }
+#endif
+    
+    // convert image to YUV color space. The output image will be created automatically. 
+    Mat I_YUV;
+    cvtColor(I, I_YUV, CV_BGR2YCrCb); 
+
+    vector<Mat> planes;    // Use the STL's vector structure to store multiple Mat objects 
+    split(I_YUV, planes);  // split the image into separate color planes (Y U V)
+
+#if 1 // change it to 0 if you want to see a blurred and noisy version of this processing
+    // Mat scanning
+    // Method 1. process Y plane using an iterator
+    MatIterator_<uchar> it = planes[0].begin<uchar>(), it_end = planes[0].end<uchar>();
+    for(; it != it_end; ++it)
+    {
+        double v = *it * 1.7 + rand()%21 - 10;
+        *it = saturate_cast<uchar>(v*v/255);
+    }
+    
+    for( int y = 0; y < I_YUV.rows; y++ )
+    {
+        // Method 2. process the first chroma plane using pre-stored row pointer.
+        uchar* Uptr = planes[1].ptr<uchar>(y);
+        for( int x = 0; x < I_YUV.cols; x++ )
+        {
+            Uptr[x] = saturate_cast<uchar>((Uptr[x]-128)/2 + 128);
+            
+            // Method 3. process the second chroma plane using individual element access
+            uchar& Vxy = planes[2].at<uchar>(y, x);
+            Vxy =        saturate_cast<uchar>((Vxy-128)/2 + 128);
+        }
+    }
+
+#else
+    
+    Mat noisyI(I.size(), CV_8U);           // Create a matrix of the specified size and type
+    
+    // Fills the matrix with normally distributed random values (around number with deviation off).
+    // There is also randu() for uniformly distributed random number generation
+    randn(noisyI, Scalar::all(128), Scalar::all(20)); 
+    
+    // blur the noisyI a bit, kernel size is 3x3 and both sigma's are set to 0.5
+    GaussianBlur(noisyI, noisyI, Size(3, 3), 0.5, 0.5); 
+
+    const double brightness_gain = 0;
+    const double contrast_gain = 1.7;
+
+#ifdef DEMO_MIXED_API_USE
+    // To pass the new matrices to the functions that only work with IplImage or CvMat do:
+    // step 1) Convert the headers (tip: data will not be copied).
+    // step 2) call the function   (tip: to pass a pointer do not forget unary "&" to form pointers)
+    
+    IplImage cv_planes_0 = planes[0], cv_noise = noisyI;    
+    cvAddWeighted(&cv_planes_0, contrast_gain, &cv_noise, 1, -128 + brightness_gain, &cv_planes_0);
+#else
+    addWeighted(planes[0], contrast_gain, noisyI, 1, -128 + brightness_gain, planes[0]);
+#endif
+    
+    const double color_scale = 0.5;
+    // Mat::convertTo() replaces cvConvertScale. 
+    // One must explicitly specify the output matrix type (we keep it intact - planes[1].type())
+    planes[1].convertTo(planes[1], planes[1].type(), color_scale, 128*(1-color_scale));
+
+    // alternative form of cv::convertScale if we know the datatype at compile time ("uchar" here).
+    // This expression will not create any temporary arrays ( so should be almost as fast as above)
+    planes[2] = Mat_<uchar>(planes[2]*color_scale + 128*(1-color_scale));
+
+    // Mat::mul replaces cvMul(). Again, no temporary arrays are created in case of simple expressions.
+    planes[0] = planes[0].mul(planes[0], 1./255);
+#endif
+
+    
+    merge(planes, I_YUV);                // now merge the results back
+    cvtColor(I_YUV, I, CV_YCrCb2BGR);  // and produce the output RGB image
+
+    
+    namedWindow("image with grain", CV_WINDOW_AUTOSIZE);   // use this to create images
+
+#ifdef DEMO_MIXED_API_USE
+    // this is to demonstrate that I and IplI really share the data - the result of the above
+    // processing is stored in I and thus in IplI too.
+    cvShowImage("image with grain", IplI);
+#else
+    imshow("image with grain", I); // the new MATLAB style function show
+#endif
+    waitKey();
+
+    // Tip: No memory freeing is required! 
+    //      All the memory will be automatically released by the Vector<>, Mat and Ptr<> destructor.
+    return 0;    
+}
diff --git a/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp
new file mode 100644
index 0000000000..6b18f95f97
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp
@@ -0,0 +1,86 @@
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <iostream>
+
+using namespace std; 
+using namespace cv;
+
+void help(char* progName)
+{
+    cout << endl 
+        <<  "This program shows how to filter images with mask: the write it yourself and the"
+        << "filter2d way. " << endl
+        <<  "Usage:"                                                                        << endl
+        << progName << " [image_name -- default lena.jpg] [G -- grayscale] "        << endl << endl;
+}
+
+
+void Sharpen(const Mat& myImage,Mat& Result);
+
+int main( int argc, char* argv[])
+{
+    help(argv[0]);
+    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
+
+    Mat I, J, K;
+
+    if (argc >= 3 && !strcmp("G", argv[2]))
+        I = imread( filename, CV_LOAD_IMAGE_GRAYSCALE);
+    else
+        I = imread( filename, CV_LOAD_IMAGE_COLOR);
+
+    namedWindow("Input", CV_WINDOW_AUTOSIZE);
+    namedWindow("Output", CV_WINDOW_AUTOSIZE);
+
+    imshow("Input", I);
+    double t = (double)getTickCount();
+    
+    Sharpen(I, J); 
+    
+    t = ((double)getTickCount() - t)/getTickFrequency();
+    cout << "Hand written function times passed in seconds: " << t << endl;
+
+    imshow("Output", J);
+    cvWaitKey(0);
+
+    Mat kern = (Mat_<char>(3,3) <<  0, -1,  0, 
+                                   -1,  5, -1,
+                                    0, -1,  0);
+    t = (double)getTickCount();
+    filter2D(I, K, I.depth(), kern ); 
+    t = ((double)getTickCount() - t)/getTickFrequency();
+    cout << "Built-in filter2D time passed in seconds:      " << t << endl;
+
+    imshow("Output", K);
+
+    cvWaitKey(0);
+    return 0; 
+}
+void Sharpen(const Mat& myImage,Mat& Result)
+{
+    CV_Assert(myImage.depth() == CV_8U);  // accept only uchar images
+
+    const int nChannels = myImage.channels();
+    Result.create(myImage.size(),myImage.type());
+    
+    for(int j = 1 ; j < myImage.rows-1; ++j)
+    {
+        const uchar* previous = myImage.ptr<uchar>(j - 1);
+        const uchar* current  = myImage.ptr<uchar>(j    );
+        const uchar* next     = myImage.ptr<uchar>(j + 1);
+
+        uchar* output = Result.ptr<uchar>(j);
+
+        for(int i= nChannels;i < nChannels*(myImage.cols-1); ++i)
+        {
+            *output++ = saturate_cast<uchar>(5*current[i] 
+                         -current[i-nChannels] - current[i+nChannels] - previous[i] - next[i]);
+        }
+    }
+
+    Result.row(0).setTo(Scalar(0));
+    Result.row(Result.rows-1).setTo(Scalar(0));
+    Result.col(0).setTo(Scalar(0));
+    Result.col(Result.cols-1).setTo(Scalar(0));
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
new file mode 100644
index 0000000000..2b6c9af467
--- /dev/null
+++ b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
@@ -0,0 +1,85 @@
+/*  For description look into the help() function. */
+
+#include "opencv2/core/core.hpp"
+#include <iostream>
+
+using namespace std;
+using namespace cv;
+
+void help()
+{
+    cout
+    << "\n--------------------------------------------------------------------------" << endl
+    << "This program shows how to create matrices(cv::Mat) in OpenCV and its serial"
+    << " out capabilities"                                                            << endl
+    << "That is, cv::Mat M(...); M.create and cout << M. "                            << endl
+    << "Shows how output can be formated to OpenCV, python, numpy, csv and C styles." << endl
+    << "Usage:"                                                                       << endl
+    << "./cvout_sample"                                                               << endl
+    << "--------------------------------------------------------------------------"   << endl 
+    << endl;
+}
+
+int main(int,char**)
+{
+    help();    
+    // create by using the constructor
+    Mat M(2,2, CV_8UC3, Scalar(0,0,255)); 
+    cout << "M = " << endl << " " << M << endl << endl;   
+
+    // create by using the create function()
+    M.create(4,4, CV_8UC(2));
+    cout << "M = "<< endl << " "  << M << endl << endl;
+
+    // create multidimensional matrices
+    int sz[3] = {2,2,2}; 
+    Mat L(3,sz, CV_8UC(1), Scalar::all(0));
+    // Cannot print via operator <<
+
+    // Create using MATLAB style eye, ones or zero matrix
+    Mat E = Mat::eye(4, 4, CV_64F);    
+    cout << "E = " << endl << " " << E << endl << endl;
+    
+    Mat O = Mat::ones(2, 2, CV_32F);    
+    cout << "O = " << endl << " " << O << endl << endl;
+
+    Mat Z = Mat::zeros(3,3, CV_8UC1);
+    cout << "Z = " << endl << " " << Z << endl << endl;
+    
+    // create a 3x3 double-precision identity matrix
+    Mat C = (Mat_<double>(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0); 
+    cout << "C = " << endl << " " << C << endl << endl;
+
+    Mat RowClone = C.row(1).clone();
+    cout << "RowClone = " << endl << " " << RowClone << endl << endl;
+
+    // Fill a matrix with random values
+    Mat R = Mat(3, 2, CV_8UC3);
+    randu(R, Scalar::all(0), Scalar::all(255));
+
+    // Demonstrate the output formating options
+    cout << "R (default) = " << endl <<        R           << endl << endl;
+    cout << "R (python)  = " << endl << format(R,"python") << endl << endl;
+    cout << "R (numpy)   = " << endl << format(R,"numpy" ) << endl << endl;
+    cout << "R (csv)     = " << endl << format(R,"csv"   ) << endl << endl;
+    cout << "R (c)       = " << endl << format(R,"C"     ) << endl << endl;
+
+    Point2f P(5, 1);
+    cout << "Point (2D) = " << P << endl << endl;
+
+    Point3f P3f(2, 6, 7);
+    cout << "Point (3D) = " << P3f << endl << endl;
+
+
+    vector<float> v;
+    v.push_back( (float)CV_PI);   v.push_back(2);    v.push_back(3.01f);
+    
+    cout << "Vector of floats via Mat = " << Mat(v) << endl << endl;
+        
+    vector<Point2f> vPoints(20);
+    for (size_t E = 0; E < vPoints.size(); ++E)
+        vPoints[E] = Point2f((float)(E * 5), (float)(E % 7));
+
+    cout << "A vector of 2D Points = " << vPoints << endl << endl;
+    return 0;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/features2D/SURF_FlannMatcher.cpp b/samples/cpp/tutorial_code/features2D/SURF_FlannMatcher.cpp
new file mode 100644
index 0000000000..2e3c1eba21
--- /dev/null
+++ b/samples/cpp/tutorial_code/features2D/SURF_FlannMatcher.cpp
@@ -0,0 +1,97 @@
+/**
+ * @file SURF_FlannMatcher
+ * @brief SURF detector + descriptor + FLANN Matcher
+ * @author A. Huaman
+ */
+
+#include <stdio.h>
+#include <iostream>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+using namespace cv;
+
+void readme();
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+  if( argc != 3 )
+  { readme(); return -1; }
+
+  Mat img_1 = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
+  Mat img_2 = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );
+  
+  if( !img_1.data || !img_2.data )
+  { std::cout<< " --(!) Error reading images " << std::endl; return -1; }
+
+  //-- Step 1: Detect the keypoints using SURF Detector
+  int minHessian = 400;
+
+  SurfFeatureDetector detector( minHessian );
+
+  std::vector<KeyPoint> keypoints_1, keypoints_2;
+
+  detector.detect( img_1, keypoints_1 );
+  detector.detect( img_2, keypoints_2 );
+
+  //-- Step 2: Calculate descriptors (feature vectors)
+  SurfDescriptorExtractor extractor;
+
+  Mat descriptors_1, descriptors_2;
+
+  extractor.compute( img_1, keypoints_1, descriptors_1 );
+  extractor.compute( img_2, keypoints_2, descriptors_2 );
+
+  //-- Step 3: Matching descriptor vectors using FLANN matcher
+  FlannBasedMatcher matcher;
+  std::vector< DMatch > matches;
+  matcher.match( descriptors_1, descriptors_2, matches );
+
+  double max_dist = 0; double min_dist = 100;
+
+  //-- Quick calculation of max and min distances between keypoints
+  for( int i = 0; i < descriptors_1.rows; i++ )
+  { double dist = matches[i].distance;
+    if( dist < min_dist ) min_dist = dist;
+    if( dist > max_dist ) max_dist = dist;
+  }
+
+  printf("-- Max dist : %f \n", max_dist );
+  printf("-- Min dist : %f \n", min_dist );
+  
+  //-- Draw only "good" matches (i.e. whose distance is less than 2*min_dist )
+  //-- PS.- radiusMatch can also be used here.
+  std::vector< DMatch > good_matches;
+
+  for( int i = 0; i < descriptors_1.rows; i++ )
+  { if( matches[i].distance < 2*min_dist )
+    { good_matches.push_back( matches[i]); }
+  }  
+
+  //-- Draw only "good" matches
+  Mat img_matches;
+  drawMatches( img_1, keypoints_1, img_2, keypoints_2, 
+               good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), 
+               vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); 
+
+  //-- Show detected matches
+  imshow( "Good Matches", img_matches );
+
+  for( int i = 0; i < good_matches.size(); i++ )
+  { printf( "-- Good Match [%d] Keypoint 1: %d  -- Keypoint 2: %d  \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx ); }
+
+  waitKey(0);
+
+  return 0;
+}
+
+/**
+ * @function readme
+ */
+void readme()
+{ std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
diff --git a/samples/cpp/tutorial_code/features2D/SURF_Homography.cpp b/samples/cpp/tutorial_code/features2D/SURF_Homography.cpp
new file mode 100644
index 0000000000..2b87abdd48
--- /dev/null
+++ b/samples/cpp/tutorial_code/features2D/SURF_Homography.cpp
@@ -0,0 +1,129 @@
+/**
+ * @file SURF_Homography
+ * @brief SURF detector + descriptor + FLANN Matcher + FindHomography
+ * @author A. Huaman
+ */
+
+#include <stdio.h>
+#include <iostream>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+
+using namespace cv;
+
+void readme();
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+  if( argc != 3 )
+  { readme(); return -1; }
+
+  Mat img_1 = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
+  Mat img_2 = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );
+  
+  if( !img_1.data || !img_2.data )
+  { std::cout<< " --(!) Error reading images " << std::endl; return -1; }
+
+  //-- Step 1: Detect the keypoints using SURF Detector
+  int minHessian = 400;
+
+  SurfFeatureDetector detector( minHessian );
+
+  std::vector<KeyPoint> keypoints_1, keypoints_2;
+
+  detector.detect( img_1, keypoints_1 );
+  detector.detect( img_2, keypoints_2 );
+
+  //-- Step 2: Calculate descriptors (feature vectors)
+  SurfDescriptorExtractor extractor;
+
+  Mat descriptors_1, descriptors_2;
+
+  extractor.compute( img_1, keypoints_1, descriptors_1 );
+  extractor.compute( img_2, keypoints_2, descriptors_2 );
+
+  //-- Step 3: Matching descriptor vectors using FLANN matcher
+  FlannBasedMatcher matcher;
+  std::vector< DMatch > matches;
+  matcher.match( descriptors_1, descriptors_2, matches );
+
+  double max_dist = 0; double min_dist = 100;
+
+  //-- Quick calculation of max and min distances between keypoints
+  for( int i = 0; i < descriptors_1.rows; i++ )
+  { double dist = matches[i].distance;
+    if( dist < min_dist ) min_dist = dist;
+    if( dist > max_dist ) max_dist = dist;
+  }
+
+  printf("-- Max dist : %f \n", max_dist );
+  printf("-- Min dist : %f \n", min_dist );
+  
+  //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )
+  std::vector< DMatch > good_matches;
+
+  for( int i = 0; i < descriptors_1.rows; i++ )
+  { if( matches[i].distance < 3*min_dist )
+    { good_matches.push_back( matches[i]); }
+  }  
+
+  Mat img_matches;
+  drawMatches( img_1, keypoints_1, img_2, keypoints_2, 
+               good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), 
+               vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); 
+
+
+  //-- Localize the object from img_1 in img_2 
+  std::vector<Point2f> obj;
+  std::vector<Point2f> scene;
+
+  for( int i = 0; i < good_matches.size(); i++ )
+  {
+    //-- Get the keypoints from the good matches
+    obj.push_back( keypoints_1[ good_matches[i].queryIdx ].pt );
+    scene.push_back( keypoints_2[ good_matches[i].trainIdx ].pt ); 
+  }
+
+  Mat H = findHomography( obj, scene, CV_RANSAC );
+
+  //-- Get the corners from the image_1 ( the object to be "detected" )
+  Point2f obj_corners[4] = { cvPoint(0,0), cvPoint( img_1.cols, 0 ), cvPoint( img_1.cols, img_1.rows ), cvPoint( 0, img_1.rows ) };
+  Point scene_corners[4];
+
+  //-- Map these corners in the scene ( image_2)
+  for( int i = 0; i < 4; i++ )
+  {
+    double x = obj_corners[i].x; 
+    double y = obj_corners[i].y;
+
+    double Z = 1./( H.at<double>(2,0)*x + H.at<double>(2,1)*y + H.at<double>(2,2) );
+    double X = ( H.at<double>(0,0)*x + H.at<double>(0,1)*y + H.at<double>(0,2) )*Z;
+    double Y = ( H.at<double>(1,0)*x + H.at<double>(1,1)*y + H.at<double>(1,2) )*Z;
+    scene_corners[i] = cvPoint( cvRound(X) + img_1.cols, cvRound(Y) );
+  }  
+   
+  //-- Draw lines between the corners (the mapped object in the scene - image_2 )
+  line( img_matches, scene_corners[0], scene_corners[1], Scalar(0, 255, 0), 2 );
+  line( img_matches, scene_corners[1], scene_corners[2], Scalar( 0, 255, 0), 2 );
+  line( img_matches, scene_corners[2], scene_corners[3], Scalar( 0, 255, 0), 2 );
+  line( img_matches, scene_corners[3], scene_corners[0], Scalar( 0, 255, 0), 2 );
+
+  //-- Show detected matches
+  imshow( "Good Matches & Object detection", img_matches );
+
+  waitKey(0);
+
+  return 0;
+}
+
+/**
+ * @function readme
+ */
+void readme()
+{ std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
diff --git a/samples/cpp/tutorial_code/features2D/SURF_descriptor.cpp b/samples/cpp/tutorial_code/features2D/SURF_descriptor.cpp
new file mode 100644
index 0000000000..5ea00cad8d
--- /dev/null
+++ b/samples/cpp/tutorial_code/features2D/SURF_descriptor.cpp
@@ -0,0 +1,71 @@
+/**
+ * @file SURF_descriptor
+ * @brief SURF detector + descritpor + BruteForce Matcher + drawing matches with OpenCV functions
+ * @author A. Huaman
+ */
+
+#include <stdio.h>
+#include <iostream>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+using namespace cv;
+
+void readme();
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+  if( argc != 3 )
+  { return -1; }
+
+  Mat img_1 = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
+  Mat img_2 = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );
+  
+  if( !img_1.data || !img_2.data )
+  { return -1; }
+
+  //-- Step 1: Detect the keypoints using SURF Detector
+  int minHessian = 400;
+
+  SurfFeatureDetector detector( minHessian );
+
+  std::vector<KeyPoint> keypoints_1, keypoints_2;
+
+  detector.detect( img_1, keypoints_1 );
+  detector.detect( img_2, keypoints_2 );
+
+  //-- Step 2: Calculate descriptors (feature vectors)
+  SurfDescriptorExtractor extractor;
+
+  Mat descriptors_1, descriptors_2;
+
+  extractor.compute( img_1, keypoints_1, descriptors_1 );
+  extractor.compute( img_2, keypoints_2, descriptors_2 );
+
+  //-- Step 3: Matching descriptor vectors with a brute force matcher
+  BruteForceMatcher< L2<float> > matcher;
+  std::vector< DMatch > matches;
+  matcher.match( descriptors_1, descriptors_2, matches );
+
+  //-- Draw matches
+  Mat img_matches;
+  drawMatches( img_1, keypoints_1, img_2, keypoints_2, matches, img_matches ); 
+
+  //-- Show detected matches
+  imshow("Matches", img_matches );
+
+  waitKey(0);
+
+  return 0;
+}
+
+/**
+ * @function readme
+ */
+void readme()
+{ std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
diff --git a/samples/cpp/tutorial_code/features2D/SURF_detector.cpp b/samples/cpp/tutorial_code/features2D/SURF_detector.cpp
new file mode 100644
index 0000000000..3a1d7ea3d5
--- /dev/null
+++ b/samples/cpp/tutorial_code/features2D/SURF_detector.cpp
@@ -0,0 +1,61 @@
+/**
+ * @file SURF_detector
+ * @brief SURF keypoint detection + keypoint drawing with OpenCV functions
+ * @author A. Huaman
+ */
+
+#include <stdio.h>
+#include <iostream>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+using namespace cv;
+
+void readme();
+
+/**
+ * @function main
+ * @brief Main function
+ */
+int main( int argc, char** argv )
+{
+  if( argc != 3 )
+  { readme(); return -1; }
+
+  Mat img_1 = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
+  Mat img_2 = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );
+  
+  if( !img_1.data || !img_2.data )
+  { std::cout<< " --(!) Error reading images " << std::endl; return -1; }
+
+  //-- Step 1: Detect the keypoints using SURF Detector
+  int minHessian = 400;
+
+  SurfFeatureDetector detector( minHessian );
+
+  std::vector<KeyPoint> keypoints_1, keypoints_2;
+
+  detector.detect( img_1, keypoints_1 );
+  detector.detect( img_2, keypoints_2 );
+
+  //-- Draw keypoints
+  Mat img_keypoints_1; Mat img_keypoints_2;
+
+  drawKeypoints( img_1, keypoints_1, img_keypoints_1, Scalar::all(-1), DrawMatchesFlags::DEFAULT ); 
+  drawKeypoints( img_2, keypoints_2, img_keypoints_2, Scalar::all(-1), DrawMatchesFlags::DEFAULT ); 
+
+  //-- Show detected (drawn) keypoints
+  imshow("Keypoints 1", img_keypoints_1 );
+  imshow("Keypoints 2", img_keypoints_2 );
+
+  waitKey(0);
+
+  return 0;
+}
+
+/**
+ * @function readme
+ */
+void readme()
+{ std::cout << " Usage: ./SURF_detector <img1> <img2>" << std::endl; }
diff --git a/samples/cpp/tutorial_code/images/baboon.jpg b/samples/cpp/tutorial_code/images/baboon.jpg
new file mode 100644
index 0000000000..2f98d8359b
Binary files /dev/null and b/samples/cpp/tutorial_code/images/baboon.jpg differ
diff --git a/samples/cpp/tutorial_code/images/chicky_512.png b/samples/cpp/tutorial_code/images/chicky_512.png
new file mode 100644
index 0000000000..746f8cc240
Binary files /dev/null and b/samples/cpp/tutorial_code/images/chicky_512.png differ
diff --git a/samples/cpp/tutorial_code/images/hand_sample1.jpg b/samples/cpp/tutorial_code/images/hand_sample1.jpg
new file mode 100644
index 0000000000..4c42898ec3
Binary files /dev/null and b/samples/cpp/tutorial_code/images/hand_sample1.jpg differ
diff --git a/samples/cpp/tutorial_code/images/hand_sample2.jpg b/samples/cpp/tutorial_code/images/hand_sample2.jpg
new file mode 100644
index 0000000000..8ca11f9fb1
Binary files /dev/null and b/samples/cpp/tutorial_code/images/hand_sample2.jpg differ
diff --git a/samples/cpp/tutorial_code/images/hand_sample3.jpg b/samples/cpp/tutorial_code/images/hand_sample3.jpg
new file mode 100644
index 0000000000..bd339a00a0
Binary files /dev/null and b/samples/cpp/tutorial_code/images/hand_sample3.jpg differ
diff --git a/samples/cpp/tutorial_code/images/imageTextN.png b/samples/cpp/tutorial_code/images/imageTextN.png
new file mode 100644
index 0000000000..cdb58f659c
Binary files /dev/null and b/samples/cpp/tutorial_code/images/imageTextN.png differ
diff --git a/samples/cpp/tutorial_code/images/imageTextR.png b/samples/cpp/tutorial_code/images/imageTextR.png
new file mode 100644
index 0000000000..7f90abdf09
Binary files /dev/null and b/samples/cpp/tutorial_code/images/imageTextR.png differ
diff --git a/samples/cpp/tutorial_code/images/opencv-logo.png b/samples/cpp/tutorial_code/images/opencv-logo.png
new file mode 100644
index 0000000000..8cd8155c1a
Binary files /dev/null and b/samples/cpp/tutorial_code/images/opencv-logo.png differ
diff --git a/samples/cpp/tutorial_code/images/yellowball.jpg b/samples/cpp/tutorial_code/images/yellowball.jpg
new file mode 100644
index 0000000000..ac76e08ba1
Binary files /dev/null and b/samples/cpp/tutorial_code/images/yellowball.jpg differ
diff --git a/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
new file mode 100644
index 0000000000..bdca8811e3
--- /dev/null
+++ b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
@@ -0,0 +1,30 @@
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std; 
+
+int main( int argc, char** argv )
+{ 
+	if( argc != 2) 
+	{
+	 cout <<" Usage: display_image ImageToLoadAndDisplay" << endl;
+	 return -1;
+	}
+	
+	Mat image;
+	image = imread(argv[1], CV_LOAD_IMAGE_COLOR);	// Read the file
+
+	if(! image.data )                              // Check for invalid input
+	{
+		cout <<  "Could not open or find the image" << std::endl ;
+		return -1;
+	}
+
+	namedWindow( "Display window", CV_WINDOW_AUTOSIZE );// Create a window for display.
+	imshow( "Display window", image );                   // Show our image inside it.
+
+	waitKey(0);											 // Wait for a keystroke in the window
+	return 0;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp b/samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp
new file mode 100644
index 0000000000..11cfa00648
--- /dev/null
+++ b/samples/cpp/tutorial_code/introduction/windows_visual_studio_Opencv/Test.cpp
@@ -0,0 +1,206 @@
+// Video Image PSNR and SSIM
+#include <iostream>	// for standard I/O
+#include <string>   // for strings
+#include <iomanip>  // for controlling float print precision
+#include <sstream>  // string to number conversion
+
+#include <opencv2/imgproc/imgproc.hpp>  // Gaussian Blur
+#include <opencv2/core/core.hpp>        // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/highgui/highgui.hpp>  // OpenCV window I/O
+
+using namespace std;
+using namespace cv;
+
+double getPSNR ( const Mat& I1, const Mat& I2);
+Scalar getMSSIM( const Mat& I1, const Mat& I2);
+
+void help()
+{
+    cout
+        << "\n--------------------------------------------------------------------------" << endl
+        << "This program shows how to read a video file with OpenCV. In addition, it tests the"
+        << " similarity of two input videos first with PSNR, and for the frames below a PSNR "  << endl
+        << "trigger value, also with MSSIM."<< endl
+        << "Usage:"                                                                       << endl
+        << "./video-source referenceVideo useCaseTestVideo PSNR_Trigger_Value Wait_Between_Frames " << endl
+        << "--------------------------------------------------------------------------"   << endl
+        << endl;
+}
+int main(int argc, char *argv[], char *window_name)
+{
+    help();
+    if (argc != 5)
+    {
+        cout << "Not enough parameters" << endl;
+        return -1;
+    }
+    stringstream conv;
+
+    const string sourceReference = argv[1],sourceCompareWith = argv[2];
+    int psnrTriggerValue, delay;
+    conv << argv[3] << argv[4];		  // put in the strings
+    conv >> psnrTriggerValue >> delay;// take out the numbers
+
+    char c;
+    int frameNum = -1;			// Frame counter
+
+    VideoCapture captRefrnc(sourceReference),
+                 captUndTst(sourceCompareWith);
+
+    if ( !captRefrnc.isOpened())
+    {
+        cout  << "Could not open reference " << sourceReference << endl;
+        return -1;
+    }
+
+    if( !captUndTst.isOpened())
+    {
+        cout  << "Could not open case test " << sourceCompareWith << endl;
+        return -1;
+    }
+
+    Size refS = Size((int) captRefrnc.get(CV_CAP_PROP_FRAME_WIDTH),
+                     (int) captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
+         uTSi = Size((int) captUndTst.get(CV_CAP_PROP_FRAME_WIDTH),
+                     (int) captUndTst.get(CV_CAP_PROP_FRAME_HEIGHT));
+
+    if (refS != uTSi)
+    {
+        cout << "Inputs have different size!!! Closing." << endl;
+        return -1;
+    }
+
+    const char* WIN_UT = "Under Test";
+    const char* WIN_RF = "Reference";
+
+    // Windows
+            namedWindow(WIN_RF, CV_WINDOW_AUTOSIZE );
+            namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE );
+            cvMoveWindow(WIN_RF, 400       ,            0);		 //750,  2 (bernat =0)
+            cvMoveWindow(WIN_UT, refS.width,            0);		 //1500, 2
+
+    cout << "Frame resolution: Width=" << refS.width << "  Height=" << refS.height
+         << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
+
+    cout << "PSNR trigger value " <<
+          setiosflags(ios::fixed) << setprecision(3) << psnrTriggerValue << endl;
+
+    Mat frameReference, frameUnderTest;
+    double psnrV;
+    Scalar mssimV;
+
+    while( true) //Show the image captured in the window and repeat
+    {
+        captRefrnc >> frameReference;
+        captUndTst >> frameUnderTest;
+
+        if( frameReference.empty()  || frameUnderTest.empty())
+        {
+            cout << " < < <  Game over!  > > > ";
+            break;
+        }
+
+        ++frameNum;
+        cout <<"Frame:" << frameNum;
+
+        ///////////////////////////////// PSNR ////////////////////////////////////////////////////
+        psnrV = getPSNR(frameReference,frameUnderTest);					//get PSNR
+        cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";
+
+        //////////////////////////////////// MSSIM /////////////////////////////////////////////////
+        if (psnrV < psnrTriggerValue)
+        {
+            mssimV = getMSSIM(frameReference,frameUnderTest);
+
+            cout << " MSSIM: "
+                 << "R" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[2] * 100
+                 << "G" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[1] * 100
+                 << "B" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[0] * 100;
+        }
+
+       cout << endl;
+
+        ////////////////////////////////// Show Image /////////////////////////////////////////////
+        imshow( WIN_RF, frameReference);
+        imshow( WIN_UT, frameUnderTest);
+
+        c = cvWaitKey(delay);
+        if (c == 27) break;
+    }
+
+    return 0;
+}
+
+double getPSNR(const Mat& I1, const Mat& I2)
+{
+    Mat s1;
+    absdiff(I1, I2, s1);       // |I1 - I2|
+    s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
+    s1 = s1.mul(s1);           // |I1 - I2|^2
+
+    Scalar s = sum(s1);         // sum elements per channel
+
+    double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
+
+    if( sse <= 1e-10) // for small values return zero
+        return 0;
+    else
+    {
+        double  mse =sse /(double)(I1.channels() * I1.total());
+        double psnr = 10.0*log10((255*255)/mse);
+        return psnr;
+    }
+}
+
+Scalar getMSSIM( const Mat& i1, const Mat& i2)
+{
+    const double C1 = 6.5025, C2 = 58.5225;
+    /***************************** INITS **********************************/
+    int d     = CV_32F;
+
+    Mat I1, I2;
+    i1.convertTo(I1, d);           // cannot calculate on one byte large values
+    i2.convertTo(I2, d);
+
+    Mat I2_2   = I2.mul(I2);        // I2^2
+    Mat I1_2   = I1.mul(I1);        // I1^2
+    Mat I1_I2  = I1.mul(I2);        // I1 * I2
+
+    /*************************** END INITS **********************************/
+
+    Mat mu1, mu2;   // PRELIMINARY COMPUTING
+    GaussianBlur(I1, mu1, Size(11, 11), 1.5);
+    GaussianBlur(I2, mu2, Size(11, 11), 1.5);
+
+    Mat mu1_2   =   mu1.mul(mu1);
+    Mat mu2_2   =   mu2.mul(mu2);
+    Mat mu1_mu2 =   mu1.mul(mu2);
+
+    Mat sigma1_2, sigma2_2, sigma12;
+
+    GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    ///////////////////////////////// FORMULA ////////////////////////////////
+    Mat t1, t2, t3;
+
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+
+    Mat ssim_map;
+    divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
+
+    Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
+    return mssim;
+}
\ No newline at end of file
diff --git a/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp b/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp
new file mode 100644
index 0000000000..b01059dd87
--- /dev/null
+++ b/samples/cpp/tutorial_code/ml/introduction_to_svm/introduction_to_svm.cpp
@@ -0,0 +1,68 @@
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/ml/ml.hpp>
+
+using namespace cv;
+
+int main()
+{
+    // Data for visual representation
+    int width = 512, height = 512;
+    Mat image = Mat::zeros(height, width, CV_8UC3);
+
+    // Set up training data
+    float labels[4] = {1.0, -1.0, -1.0, -1.0};
+    Mat labelsMat(3, 1, CV_32FC1, labels);
+
+    float trainingData[4][2] = { {501, 10}, {255, 10}, {501, 255}, {10, 501} };
+    Mat trainingDataMat(3, 2, CV_32FC1, trainingData);
+
+    // Set up SVM's parameters
+    CvSVMParams params;
+    params.svm_type    = CvSVM::C_SVC;
+    params.kernel_type = CvSVM::LINEAR;
+    params.term_crit   = cvTermCriteria(CV_TERMCRIT_ITER, 100, 1e-6);
+
+    // Train the SVM
+    CvSVM SVM;
+    SVM.train(trainingDataMat, labelsMat, Mat(), Mat(), params);
+    
+    Vec3b green(0,255,0), blue (255,0,0);
+    // Show the decision regions given by the SVM
+    for (int i = 0; i < image.rows; ++i)
+        for (int j = 0; j < image.cols; ++j)
+        {
+            Mat sampleMat = (Mat_<float>(1,2) << i,j);
+            float response = SVM.predict(sampleMat);
+
+            if (response == 1)
+                image.at<Vec3b>(j, i)  = green;
+            else if (response == -1) 
+                 image.at<Vec3b>(j, i)  = blue;
+        }
+
+    // Show the training data
+    int thickness = -1;
+    int lineType = 8;
+    circle(	image, Point(501,  10), 5, Scalar(  0,   0,   0), thickness, lineType);
+    circle(	image, Point(255,  10), 5, Scalar(255, 255, 255), thickness, lineType);
+    circle(	image, Point(501, 255), 5, Scalar(255, 255, 255), thickness, lineType);
+    circle(	image, Point( 10, 501), 5, Scalar(255, 255, 255), thickness, lineType);
+
+    // Show support vectors
+    thickness = 2;
+    lineType  = 8;
+    int c     = SVM.get_support_vector_count();
+
+    for (int i = 0; i < c; ++i)
+    {
+        const float* v = SVM.get_support_vector(i);
+        circle(	image,  Point( (int) v[0], (int) v[1]),   6,  Scalar(128, 128, 128), thickness, lineType);
+    }
+
+    imwrite("result.png", image);        // save the image 
+
+    imshow("SVM Simple Example", image); // show it to the user
+    waitKey(0);
+
+}
diff --git a/samples/gpu/CMakeLists.txt b/samples/gpu/CMakeLists.txt
index f84ae99353..e2cb1071ba 100644
--- a/samples/gpu/CMakeLists.txt
+++ b/samples/gpu/CMakeLists.txt
@@ -1,5 +1,8 @@
 if (BUILD_EXAMPLES)
-    project(gpu_samples)
+    set(project "gpu")
+    string(TOUPPER "${project}" project_upper)
+    
+    project("${project}_samples")
 
     include_directories(
         "${CMAKE_SOURCE_DIR}/modules/core/include"
@@ -14,10 +17,10 @@ if (BUILD_EXAMPLES)
         "${CMAKE_SOURCE_DIR}/modules/legacy/include"
         "${CMAKE_SOURCE_DIR}/modules/contrib/include"
         "${CMAKE_SOURCE_DIR}/modules/gpu/include"
-		"${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia"
-		"${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia/core"
-    )   
-    
+        "${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia"
+        "${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia/core"
+    )
+
     if(HAVE_CUDA)
         include_directories(${CUDA_INCLUDE_DIRS} ${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia ${CMAKE_SOURCE_DIR}/modules/gpu/src/nvidia/core)
     endif()
@@ -25,50 +28,50 @@ if (BUILD_EXAMPLES)
     if(CMAKE_COMPILER_IS_GNUCXX)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
     endif()
-    
+
     # ---------------------------------------------
     #      Define executable targets
     # ---------------------------------------------
     MACRO(MY_DEFINE_EXAMPLE name srcs)
-        set(the_target "example_gpu_${name}")
-    	add_executable(${the_target} ${srcs})
-		set_target_properties(${the_target} PROPERTIES
-		    OUTPUT_NAME "${name}_gpu"
-		    PROJECT_LABEL "(EXAMPLE_GPU) ${name}")
-    	add_dependencies(${the_target} opencv_core opencv_flann opencv_imgproc opencv_highgui
-    	    opencv_ml opencv_video opencv_objdetect opencv_features2d
-    	    opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
-    	target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_core
-    	    opencv_flann opencv_imgproc opencv_highgui opencv_ml opencv_video opencv_objdetect
-    	    opencv_features2d opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
-			
-		if(ENABLE_SOLUTION_FOLDERS)
-			set_target_properties(${the_target} PROPERTIES FOLDER "samples//gpu")
-		endif()
+        set(the_target "example_${project}_${name}")
+        add_executable(${the_target} ${srcs})
+        set_target_properties(${the_target} PROPERTIES
+                OUTPUT_NAME "${name}_${project}"                                       
+                PROJECT_LABEL "(EXAMPLE_${project_upper}) ${name}")
+        add_dependencies(${the_target} opencv_core opencv_flann opencv_imgproc opencv_highgui
+            opencv_ml opencv_video opencv_objdetect opencv_features2d
+            opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
+        target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_core
+            opencv_flann opencv_imgproc opencv_highgui opencv_ml opencv_video opencv_objdetect
+            opencv_features2d opencv_calib3d opencv_legacy opencv_contrib opencv_gpu)
+
+        if(ENABLE_SOLUTION_FOLDERS)
+            set_target_properties(${the_target} PROPERTIES FOLDER "samples//${project}")
+        endif()
 
         if(WIN32)
-	    if (MSVC AND NOT BUILD_SHARED_LIBS)
-	        set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
-	    endif()
-            install(TARGETS ${the_target}
-                RUNTIME DESTINATION "samples/gpu" COMPONENT main)
+            if (MSVC AND NOT BUILD_SHARED_LIBS)
+                set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
+            endif()
+            install(TARGETS ${the_target} RUNTIME DESTINATION "samples/${project}" COMPONENT main)
         endif()
     ENDMACRO(MY_DEFINE_EXAMPLE)
-    
-    file(GLOB gpu_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
-    
-    foreach(sample_filename ${gpu_samples})
+
+    file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+
+    foreach(sample_filename ${all_samples})
         get_filename_component(sample ${sample_filename} NAME_WE)
-        MY_DEFINE_EXAMPLE(${sample}  ${sample_filename})
-    endforeach()   
-    
+        file(GLOB sample_srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${sample}.*)
+        MY_DEFINE_EXAMPLE(${sample} ${sample_srcs})
+    endforeach()
+
     include("performance/CMakeLists.txt")
 endif(BUILD_EXAMPLES)
 
 if (NOT WIN32)
-    file(GLOB GPU_FILES *.c *.cpp *.jpg *.png *.data makefile.* build_all.sh *.dsp *.cmd )
-    install(FILES ${GPU_FILES}
-            DESTINATION share/opencv/samples/gpu
+    file(GLOB install_list *.c *.cpp *.jpg *.png *.data makefile.* build_all.sh *.dsp *.cmd )
+    install(FILES ${install_list}
+            DESTINATION share/opencv/samples/${project}
             PERMISSIONS OWNER_READ GROUP_READ WORLD_READ)
 endif ()
 
diff --git a/samples/gpu/cascadeclassifier_nvidia_api.cpp b/samples/gpu/cascadeclassifier_nvidia_api.cpp
index b33b447fec..923e0a3029 100644
--- a/samples/gpu/cascadeclassifier_nvidia_api.cpp
+++ b/samples/gpu/cascadeclassifier_nvidia_api.cpp
@@ -5,6 +5,7 @@
 #include "cvconfig.h"
 #include <iostream>
 #include <iomanip>
+#include <cstdio>
 #include "opencv2/opencv.hpp"
 #include "opencv2/gpu/gpu.hpp"
 
@@ -211,9 +212,9 @@ int main(int argc, const char** argv)
     //
     //==============================================================================
 
-    NCVMemNativeAllocator gpuCascadeAllocator(NCVMemoryTypeDevice, devProp.textureAlignment);
+    NCVMemNativeAllocator gpuCascadeAllocator(NCVMemoryTypeDevice, static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(gpuCascadeAllocator.isInitialized(), "Error creating cascade GPU allocator", -1);
-    NCVMemNativeAllocator cpuCascadeAllocator(NCVMemoryTypeHostPinned, devProp.textureAlignment);
+    NCVMemNativeAllocator cpuCascadeAllocator(NCVMemoryTypeHostPinned, static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(cpuCascadeAllocator.isInitialized(), "Error creating cascade CPU allocator", -1);
 
     Ncv32u haarNumStages, haarNumNodes, haarNumFeatures;
@@ -251,9 +252,9 @@ int main(int argc, const char** argv)
     //
     //==============================================================================
 
-    NCVMemStackAllocator gpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator gpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(gpuCounter.isInitialized(), "Error creating GPU memory counter", -1);
-    NCVMemStackAllocator cpuCounter(devProp.textureAlignment);
+    NCVMemStackAllocator cpuCounter(static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(cpuCounter.isInitialized(), "Error creating CPU memory counter", -1);
 
     ncvStat = process(NULL, frameSize.width, frameSize.height,
@@ -263,9 +264,9 @@ int main(int argc, const char** argv)
                       gpuCounter, cpuCounter, devProp);
     ncvAssertPrintReturn(ncvStat == NCV_SUCCESS, "Error in memory counting pass", -1);
 
-    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), devProp.textureAlignment);
+    NCVMemStackAllocator gpuAllocator(NCVMemoryTypeDevice, gpuCounter.maxSize(), static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(gpuAllocator.isInitialized(), "Error creating GPU memory allocator", -1);
-    NCVMemStackAllocator cpuAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), devProp.textureAlignment);
+    NCVMemStackAllocator cpuAllocator(NCVMemoryTypeHostPinned, cpuCounter.maxSize(), static_cast<Ncv32u>(devProp.textureAlignment));
     ncvAssertPrintReturn(cpuAllocator.isInitialized(), "Error creating CPU memory allocator", -1);
 
     printf("Initialized for frame size [%dx%d]\n", frameSize.width, frameSize.height);
diff --git a/samples/gpu/performance/tests.cpp b/samples/gpu/performance/tests.cpp
index c7ef45bade..1b2cbbc30b 100644
--- a/samples/gpu/performance/tests.cpp
+++ b/samples/gpu/performance/tests.cpp
@@ -318,7 +318,7 @@ TEST(BruteForceMatcher)
     GPU_OFF;
 
     SUBTEST << "knnMatch";
-    int knn = 10;
+    int knn = 2;
 
     CPU_ON;
     matcher.knnMatch(query, train, matches, knn);
@@ -824,3 +824,138 @@ TEST(solvePnPRansac)
         GPU_OFF;
     }
 }
+
+
+TEST(GaussianBlur)
+{
+    for (int size = 1000; size < 10000; size += 3000)
+    {
+        SUBTEST << "16SC3, size " << size;
+
+        Mat src; gen(src, size, size, CV_16SC3, 0, 256);
+        Mat dst(src.size(), src.type());
+
+        CPU_ON;
+        GaussianBlur(src, dst, Size(5,5), 0);
+        CPU_OFF;
+
+        gpu::GpuMat d_src(src);
+        gpu::GpuMat d_dst(src.size(), src.type());
+
+        GPU_ON;
+        gpu::GaussianBlur(d_src, d_dst, Size(5,5), 0);
+        GPU_OFF;
+    }
+
+    for (int size = 1000; size < 10000; size += 3000)
+    {
+        SUBTEST << "8UC4, size " << size;
+
+        Mat src; gen(src, size, size, CV_8UC4, 0, 256);
+        Mat dst(src.size(), src.type());
+
+        CPU_ON;
+        GaussianBlur(src, dst, Size(5,5), 0);
+        CPU_OFF;
+
+        gpu::GpuMat d_src(src);
+        gpu::GpuMat d_dst(src.size(), src.type());
+
+        GPU_ON;
+        gpu::GaussianBlur(d_src, d_dst, Size(5,5), 0);
+        GPU_OFF;
+    }
+}
+
+TEST(pyrDown)
+{
+    gpu::PyrDownBuf buf(Size(4000, 4000), CV_16SC3);
+
+    for (int size = 4000; size >= 1000; size -= 1000)
+    {
+        SUBTEST << "size " << size;
+
+        Mat src; gen(src, size, size, CV_16SC3, 0, 256);
+        Mat dst(Size(src.cols / 2, src.rows / 2), src.type());
+
+        CPU_ON;
+        pyrDown(src, dst);
+        CPU_OFF;
+
+        gpu::GpuMat d_src(src);
+        gpu::GpuMat d_dst(Size(src.cols / 2, src.rows / 2), src.type());
+
+        GPU_ON;
+        gpu::pyrDown(d_src, d_dst, buf);
+        GPU_OFF;
+    }
+}
+
+TEST(pyrUp)
+{
+    gpu::PyrUpBuf buf(Size(4000, 4000), CV_16SC3);
+
+    for (int size = 4000; size >= 1000; size -= 1000)
+    {
+        SUBTEST << "size " << size;
+
+        Mat src; gen(src, size, size, CV_16SC3, 0, 256);
+        Mat dst(Size(src.cols * 2, src.rows * 2), src.type());
+
+        CPU_ON;
+        pyrUp(src, dst);
+        CPU_OFF;
+
+        gpu::GpuMat d_src(src);
+        gpu::GpuMat d_dst(Size(src.cols * 2, src.rows * 2), src.type());
+
+        GPU_ON;
+        gpu::pyrUp(d_src, d_dst, buf);
+        GPU_OFF;
+    }
+}
+
+
+TEST(equalizeHist)
+{
+    for (int size = 1000; size < 4000; size += 1000)
+    {
+        SUBTEST << "size " << size;
+
+        Mat src; gen(src, size, size, CV_8UC1, 0, 256);
+        Mat dst(src.size(), src.type());
+
+        CPU_ON;
+        equalizeHist(src, dst);
+        CPU_OFF;
+
+        gpu::GpuMat d_src(src);
+        gpu::GpuMat d_dst(src.size(), src.type());
+
+        GPU_ON;
+        gpu::equalizeHist(d_src, d_dst);
+        GPU_OFF;
+    }
+}
+
+
+TEST(Canny)
+{
+    Mat img = imread(abspath("aloeL.jpg"), CV_LOAD_IMAGE_GRAYSCALE);
+
+    if (img.empty()) throw runtime_error("can't open aloeL.jpg");
+
+    Mat edges(img.size(), CV_8UC1);
+
+    CPU_ON;
+    Canny(img, edges, 50.0, 100.0);
+    CPU_OFF;
+    
+    gpu::GpuMat d_img(img);
+    gpu::GpuMat d_edges(img.size(), CV_8UC1);
+    gpu::CannyBuf d_buf(img.size());
+
+    GPU_ON;
+    gpu::Canny(d_img, d_buf, d_edges, 50.0, 100.0);
+    GPU_OFF;
+}
diff --git a/samples/python/camera.py b/samples/python/camera.py
index 7459534a0b..9a57ac5215 100644
--- a/samples/python/camera.py
+++ b/samples/python/camera.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import time
 
 cv.NamedWindow("camera", 1)
diff --git a/samples/python/camshift.py b/samples/python/camshift.py
index a1e848b43c..2f28977267 100644
--- a/samples/python/camshift.py
+++ b/samples/python/camshift.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-import cv
+import cv2.cv as cv
 
 def is_rect_nonzero(r):
     (_,_,w,h) = r
diff --git a/samples/python/chessboard.py b/samples/python/chessboard.py
index b05c70b1b0..31372b0dbd 100755
--- a/samples/python/chessboard.py
+++ b/samples/python/chessboard.py
@@ -1,5 +1,5 @@
 #!/usr/bin/python
-import cv
+import cv2.cv as cv
 import sys
 import urllib2
 
diff --git a/samples/python/contours.py b/samples/python/contours.py
index 9a69c54afc..4388b8eced 100755
--- a/samples/python/contours.py
+++ b/samples/python/contours.py
@@ -3,7 +3,7 @@
 print "OpenCV Python version of contours"
 
 # import the necessary things for OpenCV
-import cv
+import cv2.cv as cv
 
 # some default constants
 _SIZE = 500
diff --git a/samples/python/convexhull.py b/samples/python/convexhull.py
index e9affd7640..8795d0bd92 100755
--- a/samples/python/convexhull.py
+++ b/samples/python/convexhull.py
@@ -3,7 +3,7 @@
 print "OpenCV Python version of convexhull"
 
 # import the necessary things for OpenCV
-import cv
+import cv2.cv as cv
 
 # to generate random values
 import random
diff --git a/samples/python/cv20squares.py b/samples/python/cv20squares.py
index a7c560fa38..7bb0c7a9ee 100644
--- a/samples/python/cv20squares.py
+++ b/samples/python/cv20squares.py
@@ -5,7 +5,7 @@ Find Squares in image by finding countours and filtering
 #otherwise ok
 
 import math
-import cv
+import cv2.cv as cv
 
 def angle(pt1, pt2, pt0):
     "calculate angle contained by 3 points(x, y)"
diff --git a/samples/python/cvutils.py b/samples/python/cvutils.py
index 21e9a7d0ce..47785d1e72 100644
--- a/samples/python/cvutils.py
+++ b/samples/python/cvutils.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import urllib2
 from sys import argv
 
diff --git a/samples/python/delaunay.py b/samples/python/delaunay.py
index 10af4fb393..d9a4700d90 100755
--- a/samples/python/delaunay.py
+++ b/samples/python/delaunay.py
@@ -6,7 +6,7 @@ delaunay triangulation and voronoi tesselation
 Original Author (C version): ?
 Converted to Python by: Roman Stanchak
 """
-import cv
+import cv2.cv as cv
 import random
 
 def draw_subdiv_point( img, fp, color ):
diff --git a/samples/python/demhist.py b/samples/python/demhist.py
index d1f720b054..a6b1019258 100755
--- a/samples/python/demhist.py
+++ b/samples/python/demhist.py
@@ -1,5 +1,5 @@
 #!/usr/bin/python
-import cv
+import cv2.cv as cv
 import sys
 import urllib2
 
diff --git a/samples/python/dft.py b/samples/python/dft.py
index 147dc665af..f4408ca819 100755
--- a/samples/python/dft.py
+++ b/samples/python/dft.py
@@ -1,5 +1,5 @@
 #!/usr/bin/python
-import cv
+import cv2.cv as cv
 import sys
 import urllib2
 
diff --git a/samples/python/distrans.py b/samples/python/distrans.py
index e5414e5a0f..aee9357169 100755
--- a/samples/python/distrans.py
+++ b/samples/python/distrans.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 import sys
-import cv
+import cv2.cv as cv
 import urllib2
 
 wndname = "Distance transform"
diff --git a/samples/python/dmtx.py b/samples/python/dmtx.py
index f749681aac..847f8507ec 100644
--- a/samples/python/dmtx.py
+++ b/samples/python/dmtx.py
@@ -1,4 +1,4 @@
-import cv
+import cv2.cv as cv
 import time
 from pydmtx import DataMatrix
 import numpy
diff --git a/samples/python/drawing.py b/samples/python/drawing.py
index 6b007dad12..584e599605 100755
--- a/samples/python/drawing.py
+++ b/samples/python/drawing.py
@@ -4,7 +4,7 @@ import colorsys
 
 print "OpenCV Python version of drawing"
 
-import cv
+import cv2.cv as cv
 
 def random_color(random):
     """
diff --git a/samples/python/edge.py b/samples/python/edge.py
index 33bfdb6846..5730ecd6cb 100755
--- a/samples/python/edge.py
+++ b/samples/python/edge.py
@@ -4,7 +4,7 @@ print "OpenCV Python version of edge"
 
 import sys
 import urllib2
-import cv
+import cv2.cv as cv
 
 # some definitions
 win_name = "Edge"
diff --git a/samples/python/facedetect.py b/samples/python/facedetect.py
index 0c0c9bc24d..15f8302aa1 100755
--- a/samples/python/facedetect.py
+++ b/samples/python/facedetect.py
@@ -7,7 +7,7 @@ Original C implementation by:  ?
 Python implementation by: Roman Stanchak, James Bowman
 """
 import sys
-import cv
+import cv2.cv as cv
 from optparse import OptionParser
 
 # Parameters for haar detection
diff --git a/samples/python/ffilldemo.py b/samples/python/ffilldemo.py
index 4eb4c44b06..1a2be0ebb2 100755
--- a/samples/python/ffilldemo.py
+++ b/samples/python/ffilldemo.py
@@ -2,7 +2,7 @@
 import sys
 import random
 import urllib2
-import cv
+import cv2.cv as cv
 
 im=None;
 mask=None;
diff --git a/samples/python/fitellipse.py b/samples/python/fitellipse.py
index 398437d340..725838a4db 100755
--- a/samples/python/fitellipse.py
+++ b/samples/python/fitellipse.py
@@ -13,7 +13,7 @@ Python implementation by: Roman Stanchak, James Bowman
 import sys
 import urllib2
 import random
-import cv
+import cv2.cv as cv
 
 def contour_iterator(contour):
     while contour:
diff --git a/samples/python/houghlines.py b/samples/python/houghlines.py
index 8bffdcc627..e86a70dd18 100755
--- a/samples/python/houghlines.py
+++ b/samples/python/houghlines.py
@@ -3,7 +3,7 @@
 
 import sys
 from math import sin, cos, sqrt, pi
-import cv
+import cv2.cv as cv
 import urllib2
 
 # toggle between CV_HOUGH_STANDARD and CV_HOUGH_PROBILISTIC
diff --git a/samples/python/inpaint.py b/samples/python/inpaint.py
index 1e06b93266..06444d995a 100755
--- a/samples/python/inpaint.py
+++ b/samples/python/inpaint.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import urllib2
 import sys
-import cv
+import cv2.cv as cv
 
 class Sketcher:
     def __init__(self, windowname, dests):
diff --git a/samples/python/kalman.py b/samples/python/kalman.py
index af64e8e012..36cd1ff91f 100755
--- a/samples/python/kalman.py
+++ b/samples/python/kalman.py
@@ -12,7 +12,7 @@
    Pressing ESC will stop the program.
 """
 import urllib2
-import cv
+import cv2.cv as cv
 from math import cos, sin, sqrt
 import sys
 
diff --git a/samples/python/kmeans.py b/samples/python/kmeans.py
index 36428bb171..ca5df6ebaf 100755
--- a/samples/python/kmeans.py
+++ b/samples/python/kmeans.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 import urllib2
-import cv
+import cv2.cv as cv
 from random import randint
 MAX_CLUSTERS = 5
 
diff --git a/samples/python/laplace.py b/samples/python/laplace.py
index c7d6f46c45..c1a3cfae70 100755
--- a/samples/python/laplace.py
+++ b/samples/python/laplace.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 import urllib2
-import cv
+import cv2.cv as cv
 import sys
 
 if __name__ == "__main__":
diff --git a/samples/python/lkdemo.py b/samples/python/lkdemo.py
index 2aa5843968..2071023cbe 100755
--- a/samples/python/lkdemo.py
+++ b/samples/python/lkdemo.py
@@ -5,7 +5,7 @@ print "OpenCV Python version of lkdemo"
 import sys
 
 # import the necessary things for OpenCV
-import cv
+import cv2.cv as cv
 
 #############################################################################
 # some "constants"
diff --git a/samples/python/logpolar.py b/samples/python/logpolar.py
index 6afebafed1..adbf7de081 100755
--- a/samples/python/logpolar.py
+++ b/samples/python/logpolar.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import sys
 import urllib2
-import cv
+import cv2.cv as cv
 
 src=None
 dst=None
diff --git a/samples/python/minarea.py b/samples/python/minarea.py
index 8310fbc84a..d38a7ceaf5 100755
--- a/samples/python/minarea.py
+++ b/samples/python/minarea.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python 
 
 import urllib2
-import cv
+import cv2.cv as cv
 from random import randint
 
 def roundxy(pt):
diff --git a/samples/python/minidemo.py b/samples/python/minidemo.py
index dcc2922fe7..8c5924caa8 100755
--- a/samples/python/minidemo.py
+++ b/samples/python/minidemo.py
@@ -1,6 +1,6 @@
 #! /usr/bin/env python
 
-import cv
+import cv2.cv as cv
 
 cap = cv.CreateFileCapture("../c/tree.avi")
 img = cv.QueryFrame(cap)
diff --git a/samples/python/morphology.py b/samples/python/morphology.py
index 2014675d19..efc525a69e 100755
--- a/samples/python/morphology.py
+++ b/samples/python/morphology.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import sys
 import urllib2
-import cv
+import cv2.cv as cv
 
 src = 0
 image = 0
diff --git a/samples/python/motempl.py b/samples/python/motempl.py
index 306c638fed..2b2426fb59 100755
--- a/samples/python/motempl.py
+++ b/samples/python/motempl.py
@@ -3,7 +3,7 @@ import urllib2
 import sys
 import time
 from math import cos, sin
-import cv
+import cv2.cv as cv
 
 CLOCKS_PER_SEC = 1.0
 MHI_DURATION = 1
diff --git a/samples/python/numpy_array.py b/samples/python/numpy_array.py
index e0322f361f..deb9281d61 100644
--- a/samples/python/numpy_array.py
+++ b/samples/python/numpy_array.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import urllib2
 import sys
-import cv
+import cv2.cv as cv
 import numpy
 
 # SRGB-linear conversions using NumPy - see http://en.wikipedia.org/wiki/SRGB
diff --git a/samples/python/numpy_warhol.py b/samples/python/numpy_warhol.py
index 7309997971..97f32a9ae7 100644
--- a/samples/python/numpy_warhol.py
+++ b/samples/python/numpy_warhol.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import urllib2
 import sys
-import cv
+import cv2.cv as cv
 import numpy
 
 if __name__ == "__main__":
diff --git a/samples/python/pyramid_segmentation.py b/samples/python/pyramid_segmentation.py
index fa9dbd01cb..80293e2bd8 100755
--- a/samples/python/pyramid_segmentation.py
+++ b/samples/python/pyramid_segmentation.py
@@ -1,5 +1,5 @@
 #!/usr/bin/python
-import cv
+import cv2.cv as cv
 
 class PyrSegmentation:
     def __init__(self, img0):
diff --git a/samples/python/squares.py b/samples/python/squares.py
index 6fe734deb8..ed8b8aeebe 100755
--- a/samples/python/squares.py
+++ b/samples/python/squares.py
@@ -7,7 +7,7 @@
 
 import urllib2
 from math import sqrt
-import cv
+import cv2.cv as cv
 
 thresh = 50
 img = None
diff --git a/samples/python/watershed.py b/samples/python/watershed.py
index 41075280e0..d2983e7125 100755
--- a/samples/python/watershed.py
+++ b/samples/python/watershed.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 import urllib2
 import sys
-import cv
+import cv2.cv as cv
 
 class Sketcher:
     def __init__(self, windowname, dests):
diff --git a/samples/python2/calibrate.py b/samples/python2/calibrate.py
index 2c20f228d8..96ec3ad678 100644
--- a/samples/python2/calibrate.py
+++ b/samples/python2/calibrate.py
@@ -1,5 +1,5 @@
 import numpy as np
-import cv2, cv
+import cv2
 import os
 from common import splitfn
 
@@ -38,7 +38,7 @@ if __name__ == '__main__':
             term = ( cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_COUNT, 30, 0.1 )
             cv2.cornerSubPix(img, corners, (5, 5), (-1, -1), term)
         if debug_dir:
-            vis = cv2.cvtColor(img, cv.CV_GRAY2BGR)
+            vis = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
             cv2.drawChessboardCorners(vis, pattern_size, corners, found)
             path, name, ext = splitfn(fn)
             cv2.imwrite('%s/%s_chess.bmp' % (debug_dir, name), vis)
@@ -50,10 +50,7 @@ if __name__ == '__main__':
         
         print 'ok'
 
-    camera_matrix = np.zeros((3, 3))
-    dist_coefs = np.zeros(4)
-    img_n = len(img_points)
-    rms, camera_matrix, dist_coefs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, (w, h), camera_matrix, dist_coefs)
+    rms, camera_matrix, dist_coefs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, (w, h))
     print "RMS:", rms
     print "camera matrix:\n", camera_matrix
     print "distortion coefficients: ", dist_coefs.ravel()
diff --git a/samples/python2/coherence.py b/samples/python2/coherence.py
index 66fc704e6c..191f721431 100644
--- a/samples/python2/coherence.py
+++ b/samples/python2/coherence.py
@@ -7,8 +7,7 @@
 '''
 
 import numpy as np
-import cv2, cv
-
+import cv2
 
 def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4):
     h, w = img.shape[:2]
@@ -16,14 +15,14 @@ def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4):
     for i in xrange(iter_n):
         print i,
         
-        gray = cv2.cvtColor(img, cv.CV_BGR2GRAY)
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
         eigen = cv2.cornerEigenValsAndVecs(gray, str_sigma, 3)
         eigen = eigen.reshape(h, w, 3, 2)  # [[e1, e2], v1, v2]
         x, y = eigen[:,:,1,0], eigen[:,:,1,1]
         
-        gxx = cv2.sobel(gray, cv2.CV_32F, 2, 0, ksize=sigma)
-        gxy = cv2.sobel(gray, cv2.CV_32F, 1, 1, ksize=sigma)
-        gyy = cv2.sobel(gray, cv2.CV_32F, 0, 2, ksize=sigma)
+        gxx = cv2.Sobel(gray, cv2.CV_32F, 2, 0, ksize=sigma)
+        gxy = cv2.Sobel(gray, cv2.CV_32F, 1, 1, ksize=sigma)
+        gyy = cv2.Sobel(gray, cv2.CV_32F, 0, 2, ksize=sigma)
         gvv = x*x*gxx + 2*x*y*gxy + y*y*gyy
         m = gvv < 0
 
diff --git a/samples/python2/color_histogram.py b/samples/python2/color_histogram.py
index cdb7d430e3..87041fcc51 100644
--- a/samples/python2/color_histogram.py
+++ b/samples/python2/color_histogram.py
@@ -1,5 +1,5 @@
 import numpy as np
-import cv2, cv
+import cv2
 from time import clock
 import sys
 
@@ -10,7 +10,7 @@ h, s = np.indices(hsv_map.shape[:2])
 hsv_map[:,:,0] = h
 hsv_map[:,:,1] = s
 hsv_map[:,:,2] = 255
-hsv_map = cv2.cvtColor(hsv_map, cv.CV_HSV2BGR)
+hsv_map = cv2.cvtColor(hsv_map, cv2.COLOR_HSV2BGR)
 cv2.imshow('hsv_map', hsv_map)
 
 cv2.namedWindow('hist', 0)
@@ -31,7 +31,7 @@ while True:
     
     small = cv2.pyrDown(frame)
 
-    hsv = cv2.cvtColor(small, cv.CV_BGR2HSV)
+    hsv = cv2.cvtColor(small, cv2.COLOR_BGR2HSV)
     dark = hsv[...,2] < 32
     hsv[dark] = 0
     h = cv2.calcHist( [hsv], [0, 1], None, [180, 256], [0, 180, 0, 256] )
diff --git a/samples/python2/common.py b/samples/python2/common.py
index b32d60b136..e6586029cc 100644
--- a/samples/python2/common.py
+++ b/samples/python2/common.py
@@ -54,3 +54,64 @@ def mtx2rvec(R):
     axis = np.cross(vt[0], vt[1])
     return axis * np.arctan2(s, c)
 
+def draw_str(dst, (x, y), s):
+    cv2.putText(dst, s, (x+1, y+1), cv2.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 0), thickness = 2, linetype=cv2.CV_AA)
+    cv2.putText(dst, s, (x, y), cv2.FONT_HERSHEY_PLAIN, 1.0, (255, 255, 255), linetype=cv2.CV_AA)
+
+class Sketcher:
+    def __init__(self, windowname, dests, colors_func):
+        self.prev_pt = None
+        self.windowname = windowname
+        self.dests = dests
+        self.colors_func = colors_func
+        self.dirty = False
+        self.show()
+        cv2.setMouseCallback(self.windowname, self.on_mouse)
+
+    def show(self):
+        cv2.imshow(self.windowname, self.dests[0])
+
+    def on_mouse(self, event, x, y, flags, param):
+        pt = (x, y)
+        if event == cv2.EVENT_LBUTTONDOWN:
+            self.prev_pt = pt
+        if self.prev_pt and flags & cv2.EVENT_FLAG_LBUTTON:
+            for dst, color in zip(self.dests, self.colors_func()):
+                cv2.line(dst, self.prev_pt, pt, color, 5)
+            self.dirty = True
+            self.prev_pt = pt
+            self.show()
+        else:
+            self.prev_pt = None
+
+
+# palette data from matplotlib/_cm.py
+_jet_data =   {'red':   ((0., 0, 0), (0.35, 0, 0), (0.66, 1, 1), (0.89,1, 1),
+                         (1, 0.5, 0.5)),
+               'green': ((0., 0, 0), (0.125,0, 0), (0.375,1, 1), (0.64,1, 1),
+                         (0.91,0,0), (1, 0, 0)),
+               'blue':  ((0., 0.5, 0.5), (0.11, 1, 1), (0.34, 1, 1), (0.65,0, 0),
+                         (1, 0, 0))}
+
+cmap_data = { 'jet' : _jet_data }
+
+def make_cmap(name, n=256):
+    data = cmap_data[name]
+    xs = np.linspace(0.0, 1.0, n)
+    channels = []
+    eps = 1e-6
+    for ch_name in ['blue', 'green', 'red']:
+        ch_data = data[ch_name]
+        xp, yp = [], []
+        for x, y1, y2 in ch_data:
+            xp += [x, x+eps]
+            yp += [y1, y2]
+        ch = np.interp(xs, xp, yp)
+        channels.append(ch)
+    return np.uint8(np.array(channels).T*255)
+
+def nothing(*arg, **kw):
+    pass
+
+def clock():
+    return cv2.getTickCount() / cv2.getTickFrequency()
\ No newline at end of file
diff --git a/samples/python2/contours.py b/samples/python2/contours.py
new file mode 100644
index 0000000000..b546e58650
--- /dev/null
+++ b/samples/python2/contours.py
@@ -0,0 +1,48 @@
+import numpy as np
+import cv2
+
+def make_image():
+    img = np.zeros((500, 500), np.uint8)
+    black, white = 0, 255
+    for i in xrange(6):
+        dx = (i%2)*250 - 30
+        dy = (i/2)*150
+        
+        if i == 0:
+            for j in xrange(11):
+                angle = (j+5)*np.pi/21
+                c, s = np.cos(angle), np.sin(angle)
+                x1, y1 = np.int32([dx+100+j*10-80*c, dy+100-90*s])
+                x2, y2 = np.int32([dx+100+j*10-30*c, dy+100-30*s])
+                cv2.line(img, (x1, y1), (x2, y2), white)
+        
+        cv2.ellipse( img, (dx+150, dy+100), (100,70), 0, 0, 360, white, -1 )
+        cv2.ellipse( img, (dx+115, dy+70), (30,20), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+185, dy+70), (30,20), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+115, dy+70), (15,15), 0, 0, 360, white, -1 )
+        cv2.ellipse( img, (dx+185, dy+70), (15,15), 0, 0, 360, white, -1 )
+        cv2.ellipse( img, (dx+115, dy+70), (5,5), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+185, dy+70), (5,5), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+150, dy+100), (10,5), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+150, dy+150), (40,10), 0, 0, 360, black, -1 )
+        cv2.ellipse( img, (dx+27, dy+100), (20,35), 0, 0, 360, white, -1 )
+        cv2.ellipse( img, (dx+273, dy+100), (20,35), 0, 0, 360, white, -1 )
+    return img
+
+if __name__ == '__main__':
+    img = make_image()
+    h, w = img.shape[:2]
+
+    contours0, hierarchy = cv2.findContours( img.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    contours = [cv2.approxPolyDP(cnt, 3, True) for cnt in contours0]
+    
+    def update(levels):
+        vis = np.zeros((h, w, 3), np.uint8)
+        levels = levels - 3
+        cv2.drawContours( vis, contours, (-1, 3)[levels <= 0], (128,255,255), 
+            3, cv2.CV_AA, hierarchy, abs(levels) )
+        cv2.imshow('contours', vis)
+    update(3)
+    cv2.createTrackbar( "levels+3", "contours", 3, 7, update )
+    cv2.imshow('image', img)
+    cv2.waitKey()
\ No newline at end of file
diff --git a/samples/python2/distrans.py b/samples/python2/distrans.py
new file mode 100644
index 0000000000..c200e7d290
--- /dev/null
+++ b/samples/python2/distrans.py
@@ -0,0 +1,56 @@
+import numpy as np
+import cv2
+import cv2.cv as cv
+from common import make_cmap
+
+help_message = '''USAGE: distrans.py [<image>]
+
+Keys:
+  ESC   - exit
+  v     - toggle voronoi mode
+'''
+
+if __name__ == '__main__':
+    import sys
+    try: fn = sys.argv[1]
+    except: fn = '../cpp/fruits.jpg'
+    print help_message
+
+    img = cv2.imread(fn, 0)
+    cm = make_cmap('jet')
+    need_update = True
+    voronoi = False
+
+    def update(dummy=None):
+        global need_update
+        need_update = False
+        thrs = cv2.getTrackbarPos('threshold', 'distrans')
+        mark = cv2.Canny(img, thrs, 3*thrs)
+        dist, labels = cv2.distanceTransform(~mark, cv.CV_DIST_L2, 5)
+        if voronoi:
+            vis = cm[np.uint8(labels)]
+        else:
+            vis = cm[np.uint8(dist*2)]
+        vis[mark != 0] = 255
+        cv2.imshow('distrans', vis)
+
+    def invalidate(dummy=None):
+        global need_update
+        need_update = True
+
+    cv2.namedWindow('distrans') 
+    cv2.createTrackbar('threshold', 'distrans', 60, 255, invalidate)
+    update()
+
+
+    while True:
+        ch = cv2.waitKey(50)
+        if ch == 27:
+            break
+        if ch == ord('v'):
+            voronoi = not voronoi
+            print 'showing', ['distance', 'voronoi'][voronoi]
+            update()
+        if need_update:
+            update()
+      
diff --git a/samples/python2/edge.py b/samples/python2/edge.py
index c2482aecb4..9b72dd80f2 100644
--- a/samples/python2/edge.py
+++ b/samples/python2/edge.py
@@ -1,4 +1,4 @@
-import cv2, cv
+import cv2
 import video
 import sys
 
@@ -15,10 +15,10 @@ cv2.createTrackbar('thrs2', 'edge', 4000, 5000, nothing)
 cap = video.create_capture(fn)
 while True:
     flag, img = cap.read()
-    gray = cv2.cvtColor(img, cv.CV_BGR2GRAY)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     thrs1 = cv2.getTrackbarPos('thrs1', 'edge')
     thrs2 = cv2.getTrackbarPos('thrs2', 'edge')
-    edge = cv2.canny(gray, thrs1, thrs2, apertureSize=5)
+    edge = cv2.Canny(gray, thrs1, thrs2, apertureSize=5)
     vis = img.copy()
     vis /= 2
     vis[edge != 0] = (0, 255, 0)
diff --git a/samples/python2/facedetect.py b/samples/python2/facedetect.py
new file mode 100644
index 0000000000..5fe9951295
--- /dev/null
+++ b/samples/python2/facedetect.py
@@ -0,0 +1,59 @@
+import numpy as np
+import cv2
+import cv2.cv as cv
+from video import create_capture
+from common import clock, draw_str
+
+help_message = '''
+USAGE: facedetect.py [--cascade <cascade_fn>] [--nested-cascade <cascade_fn>] [<video_source>]
+'''
+
+def detect(img, cascade):
+    rects = cascade.detectMultiScale(img, scaleFactor=1.3, minNeighbors=4, minSize=(30, 30), flags = cv.CV_HAAR_SCALE_IMAGE)
+    if len(rects) == 0:
+        return []
+    rects[:,2:] += rects[:,:2]
+    return rects
+
+def draw_rects(img, rects, color):
+    for x1, y1, x2, y2 in rects:
+        cv2.rectangle(img, (x1, y1), (x2, y2), color, 2)
+
+if __name__ == '__main__':
+    import sys, getopt
+    print help_message
+    
+    args, video_src = getopt.getopt(sys.argv[1:], '', ['cascade=', 'nested-cascade='])
+    try: video_src = video_src[0]
+    except: video_src = 'synth:bg=../cpp/lena.jpg:noise=0.05'
+    args = dict(args)
+    cascade_fn = args.get('--cascade', "../../data/haarcascades/haarcascade_frontalface_alt.xml")
+    nested_fn  = args.get('--nested-cascade', "../../data/haarcascades/haarcascade_eye.xml")
+
+    cascade = cv2.CascadeClassifier(cascade_fn)
+    nested = cv2.CascadeClassifier(nested_fn)
+
+    cam = create_capture(video_src)
+
+    while True:
+        ret, img = cam.read()
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        gray = cv2.equalizeHist(gray)
+        
+        t = clock()
+        rects = detect(gray, cascade)
+        vis = img.copy()
+        draw_rects(vis, rects, (0, 255, 0))
+        for x1, y1, x2, y2 in rects:
+            roi = gray[y1:y2, x1:x2]
+            vis_roi = vis[y1:y2, x1:x2]
+            subrects = detect(roi.copy(), nested)
+            draw_rects(vis_roi, subrects, (255, 0, 0))
+        dt = clock() - t
+
+        draw_str(vis, (20, 20), 'time: %.1f ms' % (dt*1000))
+        cv2.imshow('facedetect', vis)
+
+        if cv2.waitKey(5) == 27:
+            break
+
diff --git a/samples/python2/find_obj.py b/samples/python2/find_obj.py
new file mode 100644
index 0000000000..1dc9c3c842
--- /dev/null
+++ b/samples/python2/find_obj.py
@@ -0,0 +1,79 @@
+import numpy as np
+import cv2
+from common import anorm
+
+help_message = '''SURF image match 
+
+USAGE: findobj.py [ <image1> <image2> ]
+'''
+
+
+def match(desc1, desc2, r_threshold = 0.75):
+    res = []
+    for i in xrange(len(desc1)):
+        dist = anorm( desc2 - desc1[i] )
+        n1, n2 = dist.argsort()[:2]
+        r = dist[n1] / dist[n2]
+        if r < r_threshold:
+            res.append((i, n1))
+    return np.array(res)
+
+def draw_match(img1, img2, p1, p2, status = None, H = None):
+    h1, w1 = img1.shape[:2]
+    h2, w2 = img2.shape[:2]
+    vis = np.zeros((max(h1, h2), w1+w2), np.uint8)
+    vis[:h1, :w1] = img1
+    vis[:h2, w1:w1+w2] = img2
+    vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR)
+
+    if H is not None:
+        corners = np.float32([[0, 0], [w1, 0], [w1, h1], [0, h1]])
+        corners = np.int32( cv2.perspectiveTransform(corners.reshape(1, -1, 2), H).reshape(-1, 2) + (w1, 0) )
+        cv2.polylines(vis, [corners], True, (255, 255, 255))
+    
+    if status is None:
+        status = np.ones(len(p1), np.bool_)
+    green = (0, 255, 0)
+    red = (0, 0, 255)
+    for (x1, y1), (x2, y2), inlier in zip(np.int32(p1), np.int32(p2), status):
+        col = [red, green][inlier]
+        if inlier:
+            cv2.line(vis, (x1, y1), (x2+w1, y2), col)
+            cv2.circle(vis, (x1, y1), 2, col, -1)
+            cv2.circle(vis, (x2+w1, y2), 2, col, -1)
+        else:
+            r = 2
+            thickness = 3
+            cv2.line(vis, (x1-r, y1-r), (x1+r, y1+r), col, thickness)
+            cv2.line(vis, (x1-r, y1+r), (x1+r, y1-r), col, thickness)
+            cv2.line(vis, (x2+w1-r, y2-r), (x2+w1+r, y2+r), col, thickness)
+            cv2.line(vis, (x2+w1-r, y2+r), (x2+w1+r, y2-r), col, thickness)
+    return vis
+
+if __name__ == '__main__':
+    import sys
+    try: fn1, fn2 = sys.argv[1:3]
+    except:
+        fn1 = '../c/box.png'
+        fn2 = '../c/box_in_scene.png'
+    print help_message
+
+    img1 = cv2.imread(fn1, 0)
+    img2 = cv2.imread(fn2, 0)
+
+    surf = cv2.SURF(1000)
+    kp1, desc1 = surf.detect(img1, None, False)
+    kp2, desc2 = surf.detect(img2, None, False)
+    desc1.shape = (-1, surf.descriptorSize())
+    desc2.shape = (-1, surf.descriptorSize())
+    print 'img1 - %d features, img2 - %d features' % (len(kp1), len(kp2))
+
+    m = match(desc1, desc2)
+    matched_p1 = np.array([kp1[i].pt for i, j in m])
+    matched_p2 = np.array([kp2[j].pt for i, j in m])
+    H, status = cv2.findHomography(matched_p1, matched_p2, cv2.RANSAC, 10.0)
+    print '%d / %d  inliers/matched' % (np.sum(status), len(status))
+
+    vis = draw_match(img1, img2, matched_p1, matched_p2, status, H)
+    cv2.imshow('find_obj SURF', vis)
+    cv2.waitKey()
\ No newline at end of file
diff --git a/samples/python2/floodfill.py b/samples/python2/floodfill.py
new file mode 100644
index 0000000000..3cc6c9d450
--- /dev/null
+++ b/samples/python2/floodfill.py
@@ -0,0 +1,64 @@
+import numpy as np
+import cv2
+
+help_message = '''USAGE: floodfill.py [<image>]
+
+Click on the image to set seed point
+
+Keys:
+  f     - toggle floating range
+  c     - toggle 4/8 connectivity
+  ESC   - exit
+'''
+
+if __name__ == '__main__':
+    import sys
+    try: fn = sys.argv[1]
+    except: fn = '../cpp/fruits.jpg'
+    print help_message
+
+    img = cv2.imread(fn, True)
+    h, w = img.shape[:2]
+    mask = np.zeros((h+2, w+2), np.uint8)
+    seed_pt = None
+    fixed_range = True
+    connectivity = 4
+
+    def update(dummy=None):
+        if seed_pt is None:
+            cv2.imshow('floodfill', img)
+            return
+        flooded = img.copy()
+        mask[:] = 0
+        lo = cv2.getTrackbarPos('lo', 'floodfill')
+        hi = cv2.getTrackbarPos('hi', 'floodfill')
+        flags = connectivity
+        if fixed_range:
+            flags |= cv2.FLOODFILL_FIXED_RANGE
+        cv2.floodFill(flooded, mask, seed_pt, (255, 255, 255), (lo,)*3, (hi,)*3, flags)
+        cv2.circle(flooded, seed_pt, 2, (0, 0, 255), -1)
+        cv2.imshow('floodfill', flooded)
+
+    def onmouse(event, x, y, flags, param):
+        global seed_pt
+        if flags & cv2.EVENT_FLAG_LBUTTON:
+            seed_pt = x, y
+            update()
+
+    update()
+    cv2.setMouseCallback('floodfill', onmouse)
+    cv2.createTrackbar('lo', 'floodfill', 20, 255, update)
+    cv2.createTrackbar('hi', 'floodfill', 20, 255, update)
+
+    while True:
+        ch = cv2.waitKey()
+        if ch == 27:
+            break
+        if ch == ord('f'):
+            fixed_range = not fixed_range
+            print 'using %s range' % ('floating', 'fixed')[fixed_range]
+            update()
+        if ch == ord('c'):
+            connectivity = 12-connectivity
+            print 'connectivity =', connectivity
+            update()
diff --git a/samples/python2/gaussian_mix.py b/samples/python2/gaussian_mix.py
index d7aaa2169c..ffeecc5400 100644
--- a/samples/python2/gaussian_mix.py
+++ b/samples/python2/gaussian_mix.py
@@ -2,7 +2,6 @@ import numpy as np
 from numpy import random
 import cv2
 
-
 def make_gaussians(cluster_n, img_size):
     points = []
     ref_distrs = []
@@ -20,7 +19,7 @@ def make_gaussians(cluster_n, img_size):
 def draw_gaussain(img, mean, cov, color):
     x, y = np.int32(mean)
     w, u, vt = cv2.SVDecomp(cov)
-    ang = np.rad2deg( np.arctan2(u[1, 0], u[0, 0]) )
+    ang = np.arctan2(u[1, 0], u[0, 0])*(180/np.pi)
     s1, s2 = np.sqrt(w)*3.0
     cv2.ellipse(img, (x, y), (s1, s2), ang, 0, 360, color, 1, cv2.CV_AA)
 
diff --git a/samples/python2/inpaint.py b/samples/python2/inpaint.py
new file mode 100644
index 0000000000..0ae38542bc
--- /dev/null
+++ b/samples/python2/inpaint.py
@@ -0,0 +1,35 @@
+import numpy as np
+import cv2
+from common import Sketcher
+
+help_message = '''USAGE: inpaint.py [<image>]
+
+Keys:
+  SPACE - inpaint
+  r     - reset the inpainting mask
+  ESC   - exit
+'''
+
+if __name__ == '__main__':
+    import sys
+    try: fn = sys.argv[1]
+    except: fn = '../cpp/fruits.jpg'
+    print help_message
+
+    img = cv2.imread(fn)
+    img_mark = img.copy()
+    mark = np.zeros(img.shape[:2], np.uint8)
+    sketch = Sketcher('img', [img_mark, mark], lambda : ((255, 255, 255), 255))
+
+    while True:
+        ch = cv2.waitKey()
+        if ch == 27:
+            break
+        if ch == ord(' '):
+            res = cv2.inpaint(img_mark, mark, 3, cv2.INPAINT_TELEA)
+            cv2.imshow('inpaint', res)
+        if ch == ord('r'):
+            img_mark[:] = img
+            mark[:] = 0
+            sketch.show()
+            
diff --git a/samples/python2/lk_track.py b/samples/python2/lk_track.py
new file mode 100644
index 0000000000..8a157e1787
--- /dev/null
+++ b/samples/python2/lk_track.py
@@ -0,0 +1,86 @@
+import numpy as np
+import cv2
+import video
+from common import anorm2, draw_str
+from time import clock
+
+help_message = '''
+USAGE: lk_track.py [<video_source>]
+
+Keys:
+  SPACE - reset features
+'''
+
+lk_params = dict( winSize  = (15, 15), 
+                  maxLevel = 2, 
+                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03),
+                  derivLambda = 0.0 )    
+
+feature_params = dict( maxCorners = 500, 
+                       qualityLevel = 0.3,
+                       minDistance = 7,
+                       blockSize = 7 )
+
+class App:
+    def __init__(self, video_src):
+        self.track_len = 10
+        self.detect_interval = 5
+        self.tracks = []
+        self.cam = video.create_capture(video_src)
+        self.frame_idx = 0
+
+    def run(self):
+        while True:
+            ret, frame = self.cam.read()
+            frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            vis = frame.copy()
+
+            if len(self.tracks) > 0:
+                img0, img1 = self.prev_gray, frame_gray
+                p0 = np.float32([tr[-1] for tr in self.tracks]).reshape(-1, 1, 2)
+                p1, st, err = cv2.calcOpticalFlowPyrLK(img0, img1, p0, None, **lk_params)
+                p0r, st, err = cv2.calcOpticalFlowPyrLK(img1, img0, p1, None, **lk_params)
+                d = abs(p0-p0r).reshape(-1, 2).max(-1)
+                good = d < 1
+                new_tracks = []
+                for tr, (x, y), good_flag in zip(self.tracks, p1.reshape(-1, 2), good):
+                    if not good_flag:
+                        continue
+                    tr.append((x, y))
+                    if len(tr) > self.track_len:
+                        del tr[0]
+                    new_tracks.append(tr)
+                    cv2.circle(vis, (x, y), 2, (0, 255, 0), -1)
+                self.tracks = new_tracks
+                cv2.polylines(vis, [np.int32(tr) for tr in self.tracks], False, (0, 255, 0))
+                draw_str(vis, (20, 20), 'track count: %d' % len(self.tracks))
+
+            if self.frame_idx % self.detect_interval == 0:
+                mask = np.zeros_like(frame_gray)
+                mask[:] = 255
+                for x, y in [np.int32(tr[-1]) for tr in self.tracks]:
+                    cv2.circle(mask, (x, y), 5, 0, -1)
+                p = cv2.goodFeaturesToTrack(frame_gray, mask = mask, **feature_params)
+                if p is not None:
+                    for x, y in np.float32(p).reshape(-1, 2):
+                        self.tracks.append([(x, y)])
+
+
+            self.frame_idx += 1
+            self.prev_gray = frame_gray
+            cv2.imshow('lk_track', vis)
+
+            ch = cv2.waitKey(1)
+            if ch == 27:
+                break
+
+def main():
+    import sys
+    try: video_src = sys.argv[1]
+    except: video_src = video.presets['chess']
+
+    print help_message
+    App(video_src).run()
+
+if __name__ == '__main__':
+    main()
diff --git a/samples/python2/morphology.py b/samples/python2/morphology.py
new file mode 100644
index 0000000000..5192ba4be4
--- /dev/null
+++ b/samples/python2/morphology.py
@@ -0,0 +1,58 @@
+import numpy as np
+import cv2
+
+
+if __name__ == '__main__':
+    import sys
+    from itertools import cycle
+    from common import draw_str
+
+    try: fn = sys.argv[1]
+    except: fn = '../cpp/baboon.jpg'
+    img = cv2.imread(fn)
+
+    modes = cycle(['erode/dilate', 'open/close', 'blackhat/tophat', 'gradient'])
+    str_modes = cycle(['ellipse', 'rect', 'cross'])
+    cur_mode = modes.next()
+    cur_str_mode = str_modes.next()
+
+    def update(dummy=None):
+        sz = cv2.getTrackbarPos('op/size', 'morphology')
+        iters = cv2.getTrackbarPos('iters', 'morphology')
+        opers = cur_mode.split('/')
+        if len(opers) > 1:
+            sz = sz - 10
+            op = opers[sz > 0]
+            sz = abs(sz)
+        else:
+            op = opers[0]
+        sz = sz*2+1
+
+        str_name = 'MORPH_' + cur_str_mode.upper()
+        oper_name = 'MORPH_' + op.upper()
+        st = cv2.getStructuringElement(getattr(cv2, str_name), (sz, sz))
+        res = cv2.morphologyEx(img, getattr(cv2, oper_name), st, iterations=iters)
+        
+        draw_str(res, (10, 20), 'mode: ' + cur_mode)
+        draw_str(res, (10, 40), 'operation: ' + oper_name)
+        draw_str(res, (10, 60), 'structure: ' + str_name)
+        draw_str(res, (10, 80), 'ksize: %d  iters: %d' % (sz, iters))
+        cv2.imshow('morphology', res)
+
+    cv2.namedWindow('morphology')
+    cv2.createTrackbar('op/size', 'morphology', 12, 20, update)
+    cv2.createTrackbar('iters', 'morphology', 1, 10, update)
+    update()
+    print "Controls:"
+    print "  1 - change operation"
+    print "  2 - change structure element shape"
+    print
+    while True:
+        ch = cv2.waitKey()
+        if ch == 27:
+            break
+        if ch == ord('1'):
+            cur_mode = modes.next()
+        if ch == ord('2'):
+            cur_str_mode = str_modes.next()
+        update()
diff --git a/samples/python2/motempl.py b/samples/python2/motempl.py
new file mode 100644
index 0000000000..21ba0a42b2
--- /dev/null
+++ b/samples/python2/motempl.py
@@ -0,0 +1,80 @@
+import numpy as np
+import cv2
+import video
+from common import nothing, clock, draw_str
+
+MHI_DURATION = 0.5
+DEFAULT_THRESHOLD = 32
+MAX_TIME_DELTA = 0.25
+MIN_TIME_DELTA = 0.05
+
+def draw_motion_comp(vis, (x, y, w, h), angle, color):
+    cv2.rectangle(vis, (x, y), (x+w, y+h), (0, 255, 0))
+    r = min(w/2, h/2)
+    cx, cy = x+w/2, y+h/2
+    angle = np.deg2rad(angle)
+    cv2.circle(vis, (cx, cy), r, color, 3)
+    cv2.line(vis, (cx, cy), (int(cx+np.cos(angle)*r), int(cy+np.sin(angle)*r)), color, 3)
+
+if __name__ == '__main__':
+    import sys
+    try: video_src = sys.argv[1]
+    except: video_src = 'synth:class=chess:bg=../cpp/lena.jpg:noise=0.01'
+
+    cv2.namedWindow('motempl')
+    visuals = ['input', 'frame_diff', 'motion_hist', 'grad_orient']
+    cv2.createTrackbar('visual', 'motempl', 2, len(visuals)-1, nothing)
+    cv2.createTrackbar('threshold', 'motempl', DEFAULT_THRESHOLD, 255, nothing)
+
+    cam = video.create_capture(video_src)
+    ret, frame = cam.read()
+    h, w = frame.shape[:2]
+    prev_frame = frame.copy()
+    motion_history = np.zeros((h, w), np.float32)
+    hsv = np.zeros((h, w, 3), np.uint8)
+    hsv[:,:,1] = 255
+    while True:
+        ret, frame = cam.read()
+        frame_diff = cv2.absdiff(frame, prev_frame)
+        gray_diff = cv2.cvtColor(frame_diff, cv2.COLOR_BGR2GRAY)
+        thrs = cv2.getTrackbarPos('threshold', 'motempl')
+        ret, motion_mask = cv2.threshold(gray_diff, thrs, 1, cv2.THRESH_BINARY)
+        timestamp = clock()
+        cv2.updateMotionHistory(motion_mask, motion_history, timestamp, MHI_DURATION)
+        mg_mask, mg_orient = cv2.calcMotionGradient( motion_history, MAX_TIME_DELTA, MIN_TIME_DELTA, apertureSize=5 )
+        seg_mask, seg_bounds = cv2.segmentMotion(motion_history, timestamp, MAX_TIME_DELTA)
+
+        visual_name = visuals[cv2.getTrackbarPos('visual', 'motempl')]
+        if visual_name == 'input':
+            vis = frame.copy()
+        elif visual_name == 'frame_diff':
+            vis = frame_diff.copy()
+        elif visual_name == 'motion_hist':
+            vis = np.uint8(np.clip((motion_history-(timestamp-MHI_DURATION)) / MHI_DURATION, 0, 1)*255)
+            vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR)
+        elif visual_name == 'grad_orient':
+            hsv[:,:,0] = mg_orient/2
+            hsv[:,:,2] = mg_mask*255
+            vis = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+
+        for i, rect in enumerate([(0, 0, w, h)] + list(seg_bounds)):
+            x, y, rw, rh = rect
+            area = rw*rh
+            if area < 64**2:
+                continue
+            silh_roi   = motion_mask   [y:y+rh,x:x+rw]
+            orient_roi = mg_orient     [y:y+rh,x:x+rw]
+            mask_roi   = mg_mask       [y:y+rh,x:x+rw]
+            mhi_roi    = motion_history[y:y+rh,x:x+rw]
+            if cv2.norm(silh_roi, cv2.NORM_L1) < area*0.05:
+                continue
+            angle = cv2.calcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION)
+            color = ((255, 0, 0), (0, 0, 255))[i == 0]
+            draw_motion_comp(vis, rect, angle, color)
+
+        draw_str(vis, (20, 20), visual_name)
+        cv2.imshow('motempl', vis)
+
+        prev_frame = frame.copy()
+        if cv2.waitKey(5) == 27:
+            break
\ No newline at end of file
diff --git a/samples/python2/obj_detect.py b/samples/python2/obj_detect.py
index a1ddbed1c8..db62a12e5b 100644
--- a/samples/python2/obj_detect.py
+++ b/samples/python2/obj_detect.py
@@ -1,5 +1,5 @@
 import numpy as np
-import cv2, cv
+import cv2
 
 def detect(img, cascade):
     rects = cascade.detectMultiScale(img, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
@@ -9,7 +9,7 @@ def detect(img, cascade):
     return rects
 
 def detect_turned(img, cascade):
-    img = cv2.cvtColor(img, cv.CV_BGR2GRAY)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
     img = cv2.equalizeHist(img)
 
     img_t = cv2.transpose(img)
diff --git a/samples/python2/opt_flow.py b/samples/python2/opt_flow.py
new file mode 100644
index 0000000000..03cdb3f1cb
--- /dev/null
+++ b/samples/python2/opt_flow.py
@@ -0,0 +1,83 @@
+import numpy as np
+import cv2
+import video
+
+help_message = '''
+USAGE: opt_flow.py [<video_source>]
+
+Keys:
+ 1 - toggle HSV flow visualization
+ 2 - toggle glitch
+
+'''
+
+def draw_flow(img, flow, step=16):
+    h, w = img.shape[:2]
+    y, x = np.mgrid[step/2:h:step, step/2:w:step].reshape(2,-1)
+    fx, fy = flow[y,x].T
+    lines = np.vstack([x, y, x+fx, y+fy]).T.reshape(-1, 2, 2)
+    lines = np.int32(lines + 0.5)
+    vis = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    cv2.polylines(vis, lines, 0, (0, 255, 0))
+    for (x1, y1), (x2, y2) in lines:
+        cv2.circle(vis, (x1, y1), 1, (0, 255, 0), -1)
+    return vis
+
+def draw_hsv(flow):
+    h, w = flow.shape[:2]
+    fx, fy = flow[:,:,0], flow[:,:,1]
+    ang = np.arctan2(fy, fx) + np.pi
+    v = np.sqrt(fx*fx+fy*fy)
+    hsv = np.zeros((h, w, 3), np.uint8)
+    hsv[...,0] = ang*(180/np.pi/2)
+    hsv[...,1] = 255
+    hsv[...,2] = np.minimum(v*4, 255)
+    bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+    return bgr
+
+def warp_flow(img, flow):
+    h, w = flow.shape[:2]
+    flow = -flow
+    flow[:,:,0] += np.arange(w)
+    flow[:,:,1] += np.arange(h)[:,np.newaxis]
+    res = cv2.remap(img, flow, None, cv2.INTER_LINEAR)
+    return res
+
+if __name__ == '__main__':
+    import sys
+    print help_message
+    try: fn = sys.argv[1]
+    except: fn = video.presets['chess']
+
+    cam = video.create_capture(fn)
+    ret, prev = cam.read()
+    prevgray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
+    show_hsv = False
+    show_glitch = False
+    cur_glitch = prev.copy()
+
+    while True:
+        ret, img = cam.read()
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        flow = cv2.calcOpticalFlowFarneback(prevgray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+        prevgray = gray
+        
+        cv2.imshow('flow', draw_flow(gray, flow))
+        if show_hsv:
+            cv2.imshow('flow HSV', draw_hsv(flow))
+        if show_glitch:
+            cur_glitch = warp_flow(cur_glitch, flow)
+            cv2.imshow('glitch', cur_glitch)
+
+        ch = cv2.waitKey(5)
+        if ch == 27:
+            break
+        if ch == ord('1'):
+            show_hsv = not show_hsv
+            print 'HSV flow visualization is', ['off', 'on'][show_hsv]
+        if ch == ord('2'):
+            show_glitch = not show_glitch
+            if show_glitch:
+                cur_glitch = img.copy()
+            print 'glitch is', ['off', 'on'][show_glitch]
+
diff --git a/samples/python2/people_hog.txt b/samples/python2/people_hog.txt
new file mode 100644
index 0000000000..3c0ce13dd3
--- /dev/null
+++ b/samples/python2/people_hog.txt
@@ -0,0 +1,806 @@
+# from HOGDescriptor::getDefaultPeopleDetector()
+0.05359386, -0.14721455, -0.05532170, 0.05077307,
+0.11547081, -0.04268804, 0.04635834, -0.05468199, 0.08232084,
+0.10424068, -0.02294518, 0.01108519, 0.01378693, 0.11193510,
+0.01268418, 0.08528346, -0.06309239, 0.13054633, 0.08100729,
+-0.05209739, -0.04315529, 0.09341384, 0.11035026, -0.07596218,
+-0.05517511, -0.04465296, 0.02947334, 0.04555536,
+-3.55954492e-003, 0.07818956, 0.07730991, 0.07890715, 0.06222893,
+0.09001380, -0.03574381, 0.03414327, 0.05677258, -0.04773581,
+0.03746637, -0.03521175, 0.06955440, -0.03849038, 0.01052293,
+0.01736112, 0.10867710, 0.08748853, 3.29739624e-003, 0.10907028,
+0.07913758, 0.10393070, 0.02091867, 0.11594022, 0.13182420,
+0.09879354, 0.05362710, -0.06745391, -7.01260753e-003,
+5.24702156e-003, 0.03236255, 0.01407916, 0.02207983, 0.02537322,
+0.04547948, 0.07200756, 0.03129894, -0.06274468, 0.02107014,
+0.06035208, 0.08636236, 4.53164103e-003, 0.02193363, 0.02309801,
+0.05568166, -0.02645093, 0.04448695, 0.02837519, 0.08975694,
+0.04461516, 0.08975355, 0.07514391, 0.02306982, 0.10410084,
+0.06368385, 0.05943464, 4.58420580e-003, 0.05220337, 0.06675851,
+0.08358569, 0.06712101, 0.06559004, -0.03930482, -9.15936660e-003,
+-0.05897915, 0.02816453, 0.05032348, 0.06780671, 0.03377650,
+-6.09417039e-004, -0.01795146, -0.03083684, -0.01302475,
+-0.02972313, 7.88706727e-003, -0.03525961, -2.50397739e-003,
+0.05245084, 0.11791293, -0.02167498, 0.05299332, 0.06640524,
+0.05190265, -8.27316567e-003, 0.03033127, 0.05842173,
+-4.01050318e-003, -6.25105947e-003, 0.05862958, -0.02465461,
+0.05546781, -0.08228195, -0.07234028, 0.04640540, -0.01308254,
+-0.02506191, 0.03100746, -0.04665651, -0.04591486, 0.02949927,
+0.06035462, 0.02244646, -0.01698639, 0.01040041, 0.01131170,
+0.05419579, -0.02130277, -0.04321722, -0.03665198, 0.01126490,
+-0.02606488, -0.02228328, -0.02255680, -0.03427236,
+-7.75165204e-003, -0.06195229, 8.21638294e-003, 0.09535975,
+-0.03709979, -0.06942501, 0.14579427, -0.05448192, -0.02055904,
+0.05747357, 0.02781788, -0.07077577, -0.05178314, -0.10429011,
+-0.11235505, 0.07529039, -0.07559302, -0.08786739, 0.02983843,
+0.02667585, 0.01382199, -0.01797496, -0.03141199, -0.02098101,
+0.09029204, 0.04955018, 0.13718739, 0.11379953, 1.80019124e-003,
+-0.04577610, -1.11108483e-003, -0.09470536, -0.11596080,
+0.04489342, 0.01784211, 3.06850672e-003, 0.10781866,
+3.36498418e-003, -0.10842580, -0.07436839, -0.10535070,
+-0.01866805, 0.16057891, -5.07316366e-003, -0.04295658,
+-5.90488780e-003, 8.82003549e-003, -0.01492646, -0.05029279,
+-0.12875880, 8.78831954e-004, -0.01297184, -0.07592774,
+-0.02668831, -6.93787413e-004, 0.02406698, -0.01773298,
+-0.03855745, -0.05877856, 0.03259695, 0.12826584, 0.06292590,
+-4.10733931e-003, 0.10996531, 0.01332991, 0.02088735, 0.04037504,
+-0.05210760, 0.07760046, 0.06399347, -0.05751930, -0.10053057,
+0.07505023, -0.02139782, 0.01796176, 2.34400877e-003, -0.04208319,
+0.07355055, 0.05093350, -0.02996780, -0.02219072, 0.03355330,
+0.04418742, -0.05580705, -0.05037573, -0.04548179, 0.01379514,
+0.02150671, -0.02194211, -0.13682702, 0.05464972, 0.01608082,
+0.05309116, 0.04701022, 1.33690401e-003, 0.07575664, 0.09625306,
+8.92647635e-003, -0.02819123, 0.10866830, -0.03439325,
+-0.07092371, -0.06004780, -0.02712298, -7.07467366e-003,
+-0.01637020, 0.01336790, -0.10313606, 0.04906582, -0.05732445,
+-0.02731079, 0.01042235, -0.08340668, 0.03686501, 0.06108340,
+0.01322748, -0.07809529, 0.03774724, -0.03413248, -0.06096525,
+-0.04212124, -0.07982176, -1.25973229e-003, -0.03045501,
+-0.01236493, -0.06312395, 0.04789570, -0.04602066, 0.08576570,
+0.02521080, 0.02988098, 0.10314583, 0.07060035, 0.04520544,
+-0.04426654, 0.13146530, 0.08386490, 0.02164590, -2.12280243e-003,
+-0.03686353, -0.02074944, -0.03829959, -0.01530596, 0.02689708,
+0.11867401, -0.06043470, -0.02785023, -0.04775074, 0.04878745,
+0.06350956, 0.03494788, 0.01467400, 1.17890188e-003, 0.04379614,
+2.03681854e-003, -0.03958609, -0.01072688, 6.43705716e-003,
+0.02996500, -0.03418507, -0.01960307, -0.01219154,
+-4.37000440e-003, -0.02549453, 0.02646318, -0.01632513,
+6.46516960e-003, -0.01929734, 4.78711911e-003, 0.04962371,
+0.03809111, 0.07265724, 0.05758125, -0.03741554, 0.01648608,
+-8.45285598e-003, 0.03996826, -0.08185477, 0.02638875,
+-0.04026615, -0.02744674, -0.04071517, 1.05096330e-003,
+-0.04741232, -0.06733172, 8.70434940e-003, -0.02192543,
+1.35350740e-003, -0.03056974, -0.02975521, -0.02887780,
+-0.01210713, -0.04828526, -0.09066251, -0.09969629, -0.03665164,
+-8.88111943e-004, -0.06826669, -0.01866150, -0.03627640,
+-0.01408288, 0.01874239, -0.02075835, 0.09145175, -0.03547291,
+0.05396780, 0.04198981, 0.01301925, -0.03384354, -0.12201976,
+0.06830920, -0.03715654, 9.55848210e-003, 5.05685573e-003,
+0.05659294, 3.90764466e-003, 0.02808490, -0.05518097, -0.03711621,
+-0.02835565, -0.04420464, -0.01031947, 0.01883466,
+-8.49525444e-003, -0.09419250, -0.01269387, -0.02133371,
+-0.10190815, -0.07844430, 2.43644323e-003, -4.09610150e-003,
+0.01202551, -0.06452291, -0.10593818, -0.02464746, -0.02199699,
+-0.07401930, 0.07285886, 8.87513801e-004, 9.97662079e-003,
+8.46779719e-003, 0.03730333, -0.02905126, 0.03573337, -0.04393689,
+-0.12014472, 0.03176554, -2.76015815e-003, 0.10824566, 0.05090732,
+-3.30179278e-003, -0.05123822, 5.04784798e-003, -0.05664124,
+-5.99415926e-003, -0.05341901, -0.01221393, 0.01291318,
+9.91760660e-003, -7.56987557e-003, -0.06193124, -2.24549137e-003,
+0.01987562, -0.02018840, -0.06975540, -0.06601523, -0.03349112,
+-0.08910118, -0.03371435, -0.07406893, -0.02248047, -0.06159951,
+2.77751544e-003, -0.05723337, -0.04792468, 0.07518548,
+2.77279224e-003, 0.04211938, 0.03100502, 0.05278448, 0.03954679,
+-0.03006846, -0.03851741, -0.02792403, -0.02875333, 0.01531280,
+0.02186953, -0.01989829, 2.50679464e-003, -0.10258728,
+-0.04785743, -0.02887216, 3.85063468e-003, 0.01112236,
+8.29218887e-003, -0.04822981, -0.04503597, -0.03713100,
+-0.06988008, -0.11002295, -2.69209221e-003, 1.85383670e-003,
+-0.05921049, -0.06105053, -0.08458050, -0.04527602,
+8.90329306e-004, -0.05875023, -2.68602883e-003, -0.01591195,
+0.03631859, 0.05493166, 0.07300330, 5.53333294e-003, 0.06400407,
+0.01847740, -5.76280477e-003, -0.03210877, 4.25160583e-003,
+0.01166520, -1.44864211e-003, 0.02253744, -0.03367080, 0.06983195,
+-4.22323542e-003, -8.89401045e-003, -0.07943393, 0.05199728,
+0.06065201, 0.04133492, 1.44032843e-003, -0.09585235, -0.03964731,
+0.04232114, 0.01750465, -0.04487902, -7.59733608e-003, 0.02011171,
+0.04673622, 0.09011173, -0.07869188, -0.04682482, -0.05080139,
+-3.99383716e-003, -0.05346331, 0.01085723, -0.03599333,
+-0.07097908, 0.03551549, 0.02680387, 0.03471529, 0.01790393,
+0.05471273, 9.62048303e-003, -0.03180215, 0.05864431, 0.02330614,
+0.01633144, -0.05616681, -0.10245429, -0.08302189, 0.07291322,
+-0.01972590, -0.02619633, -0.02485327, -0.04627592,
+1.48853404e-003, 0.05514185, -0.01270860, -0.01948900, 0.06373586,
+0.05002292, -0.03009798, 8.76216311e-003, -0.02474238,
+-0.05504891, 1.74034527e-003, -0.03333667, 0.01524987, 0.11663762,
+-1.32344989e-003, -0.06608453, 0.05687166, -6.89525274e-004,
+-0.04402352, 0.09450210, -0.04222684, -0.05360983, 0.01779531,
+0.02561388, -0.11075410, -8.77790991e-003, -0.01099504,
+-0.10380266, 0.03103457, -0.02105741, -0.07371717, 0.05146710,
+0.10581432, -0.08617968, -0.02892107, 0.01092199, 0.14551543,
+-2.24320893e-003, -0.05818033, -0.07390742, 0.05701261,
+0.12937020, -0.04986651, 0.10182415, 0.05028650, 0.12515625,
+0.09175041, 0.06404983, 0.01523394, 0.09460562, 0.06106631,
+-0.14266998, -0.02926703, 0.02762171, 0.02164151,
+-9.58488265e-004, -0.04231362, -0.09866509, 0.04322244,
+0.05872034, -0.04838847, 0.06319253, 0.02443798, -0.03606876,
+9.38737206e-003, 0.04289991, -0.01027411, 0.08156885, 0.08751175,
+-0.13191354, 8.16054735e-003, -0.01452161, 0.02952677, 0.03615945,
+-2.09128903e-003, 0.02246693, 0.09623287, 0.09412123, -0.02924758,
+-0.07815186, -0.02203079, -2.02566991e-003, 0.01094733,
+-0.01442332, 0.02838561, 0.11882371, 7.28798332e-003, -0.10345965,
+0.07561217, -0.02049661, 4.44177445e-003, 0.01609347, -0.04893158,
+-0.08758243, -7.67420698e-003, 0.08862378, 0.06098121, 0.06565887,
+7.32981879e-003, 0.03558407, -0.03874352, -0.02490055,
+-0.06771075, 0.09939223, -0.01066077, 0.01382995, -0.07289080,
+7.47184316e-003, 0.10621431, -0.02878659, 0.02383525, -0.03274646,
+0.02137008, 0.03837290, 0.02450992, -0.04296818, -0.02895143,
+0.05327370, 0.01499020, 0.04998732, 0.12938657, 0.09391870,
+0.04292390, -0.03359194, -0.06809492, 0.01125796, 0.17290455,
+-0.03430733, -0.06255233, -0.01813114, 0.11726857, -0.06127599,
+-0.08677909, -0.03429872, 0.04684938, 0.08161420, 0.03538774,
+0.01833884, 0.11321855, 0.03261845, -0.04826299, 0.01752407,
+-0.01796414, -0.10464549, -3.30041884e-003, 2.29343961e-004,
+0.01457292, -0.02132982, -0.02602923, -9.87351313e-003,
+0.04273872, -0.02103316, -0.07994065, 0.02614958, -0.02111666,
+-0.06964913, -0.13453490, -0.06861878, -6.09341264e-003,
+0.08251446, 0.15612499, 2.46531400e-003, 8.88424646e-003,
+-0.04152999, 0.02054853, 0.05277953, -0.03087788, 0.02817579,
+0.13939077, 0.07641046, -0.03627627, -0.03015098, -0.04041540,
+-0.01360690, -0.06227205, -0.02738223, 0.13577610, 0.15235767,
+-0.05392922, -0.11175954, 0.02157129, 0.01146481, -0.05264937,
+-0.06595174, -0.02749175, 0.11812254, 0.17404149, -0.06137035,
+-0.11003478, -0.01351621, -0.01745916, -0.08577441, -0.04469909,
+-0.06106115, 0.10559758, 0.20806813, -0.09174948, 7.09621934e-004,
+0.03579374, 0.07215115, 0.02221742, 0.01827742, -7.90785067e-003,
+0.01489554, 0.14519960, -0.06425831, 0.02990399, -1.80181325e-003,
+-0.01401528, -0.04171134, -3.70530109e-003, -0.09090481,
+0.09520713, 0.08845516, -0.02651753, -0.03016730, 0.02562448,
+0.03563816, -0.03817881, 0.01433385, 0.02256983, 0.02872120,
+0.01001934, -0.06332260, 0.04338406, 0.07001807, -0.04705722,
+-0.07318907, 0.02630457, 0.03106382, 0.06648342, 0.10913180,
+-0.01630815, 0.02910308, 0.02895109, 0.08040254, 0.06969310,
+0.06797734, 6.08639978e-003, 4.16588830e-003, 0.08926726,
+-0.03123648, 0.02700146, 0.01168734, -0.01631594, 4.61015804e-003,
+8.51359498e-003, -0.03544224, 0.03571994, 4.29766066e-003,
+-0.01970077, -8.79793242e-003, 0.09607988, 0.01544222,
+-0.03923707, 0.07308586, 0.06061262, 1.31683104e-004,
+-7.98222050e-003, 0.02399261, -0.06084389, -0.02743429,
+-0.05475523, -0.04131311, 0.03559756, 0.03055342, 0.02981433,
+0.14860515, 0.01766787, 0.02945257, 0.04898238, 0.01026922,
+0.02811658, 0.08267091, 0.02732154, -0.01237693, 0.11760156,
+0.03802063, -0.03309754, 5.24957618e-003, -0.02460510, 0.02691451,
+0.05399988, -0.10133506, 0.06385437, -0.01818005, 0.02259503,
+0.03573135, 0.01042848, -0.04153402, -0.04043029, 0.01643575,
+0.08326677, 4.61383024e-004, -0.05308095, -0.08536223,
+-1.61011645e-003, -0.02163720, -0.01783352, 0.03859637,
+0.08498885, -0.01725216, 0.08625131, 0.10995087, 0.09177644,
+0.08498347, 0.07646490, 0.05580502, 0.02693516, 0.09996913,
+0.09070327, 0.06667200, 0.05873008, -0.02247842, 0.07772321,
+0.12408436, 0.12629253, -8.41997913e-004, 0.01477783, 0.09165990,
+-2.98401713e-003, -0.06466447, -0.07057302, 2.09516948e-004,
+0.02210209, -0.02158809, -0.08602506, -0.02284836,
+4.01876355e-003, 9.56660323e-003, -0.02073978, -0.04635138,
+-7.59423291e-003, -0.01377393, -0.04559359, -0.13284740,
+-0.08671406, -0.03654395, 0.01142869, 0.03287891, -0.04392983,
+0.06142959, 0.17710890, 0.10385257, 0.01329137, 0.10067633,
+0.12450829, -0.04476709, 0.09049144, 0.04589312, 0.11167907,
+0.08587538, 0.04767583, 1.67188141e-003, 0.02359802, -0.03808852,
+0.03126272, -0.01919029, -0.05698918, -0.02365112, -0.06519032,
+-0.05599358, -0.07097308, -0.03301812, -0.04719102, -0.02566297,
+0.01324074, -0.09230672, -0.05518232, -0.04712864, -0.03380903,
+-0.06719479, 0.01183908, -0.09326738, 0.01642865, 0.03789867,
+-6.61567831e-003, 0.07796386, 0.07246574, 0.04706347, -0.02523437,
+-0.01696830, -0.08068866, 0.06030888, 0.10527060, -0.06611756,
+0.02977346, 0.02621830, 0.01913855, -0.08479366, -0.06322418,
+-0.13570616, -0.07644490, 9.31900274e-003, -0.08095149,
+-0.10197903, -0.05204025, 0.01413151, -0.07800411, -0.01885122,
+-0.07509381, -0.10136326, -0.05212355, -0.09944065,
+-1.33606605e-003, -0.06342617, -0.04178550, -0.12373723,
+-0.02832736, -0.06057501, 0.05830070, 0.07604282, -0.06462587,
+8.02447461e-003, 0.11580125, 0.12332212, 0.01978462,
+-2.72378162e-003, 0.05850752, -0.04674481, 0.05148062,
+-2.62542837e-003, 0.11253355, 0.09893716, 0.09785093, -0.04659257,
+-0.01102429, -0.07002308, 0.03088913, -0.02565549, -0.07671449,
+3.17443861e-003, -0.10783514, -0.02314270, -0.11089555,
+-0.01024768, 0.03116021, -0.04964825, 0.02281825, 5.50005678e-003,
+-0.08427856, -0.14685495, -0.07719755, -0.13342668, -0.04525511,
+-0.09914210, 0.02588859, 0.03469279, 0.04664020, 0.11688190,
+0.09647275, 0.10857815, -0.01448726, 0.04299758, -0.06763151,
+1.33257592e-003, 0.14331576, 0.07574340, 0.09166205, 0.05674926,
+0.11325553, -0.01106494, 0.02062161, -0.11484840, -0.07492137,
+-0.02864293, -0.01275638, -0.06946032, -0.10101652, -0.04113498,
+-0.02214783, -0.01273942, -0.07480393, -0.10556041, -0.07622112,
+-0.09988393, -0.11453961, -0.12073903, -0.09412795, -0.07146588,
+-0.04054537, -0.06127083, 0.04221122, 0.07688113, 0.04099256,
+0.12663734, 0.14683802, 0.21761774, 0.12525328, 0.18431792,
+-1.66402373e-003, 2.37777247e-003, 0.01445475, 0.03509416,
+0.02654697, 0.01716739, 0.05374011, 0.02944174, 0.11323927,
+-0.01485456, -0.01611330, -1.85554172e-003, -0.01708549,
+-0.05435753, -0.05302101, 0.05260378, -0.03582945,
+-3.42867890e-004, 1.36076682e-003, -0.04436073, -0.04228432,
+0.03281291, -0.05480836, -0.10197772, -0.07206279, -0.10741059,
+-0.02366946, 0.10278475, -2.74783419e-003, -0.03242477,
+0.02308955, 0.02835869, 0.10348799, 0.19580358, 0.10252027,
+0.08039929, 0.05525554, -0.13250865, -0.14395352, 3.13586881e-003,
+-0.03387071, 8.94669443e-003, 0.05406157, -4.97324532e-003,
+-0.01189114, 2.82919413e-004, -0.03901557, -0.04898705,
+0.02164520, -0.01382906, -0.01850416, 0.01869347, -0.02450060,
+0.02291678, 0.08196463, 0.03309153, -0.10629974, 0.02473924,
+0.05344394, -0.02404823, -0.03243643, -5.55244600e-003,
+-0.08009996, 0.02811539, 0.04235742, 0.01859004, 0.04902123,
+-0.01438252, -0.01526853, 0.02044195, -0.05008660, 0.04244113,
+0.07611816, 0.04950470, -0.06020549, -4.26026015e-003, 0.13133512,
+-0.01438738, -0.01958807, -0.04044152, -0.12425045,
+2.84353318e-003, -0.05042776, -0.09121484, 7.34345755e-003,
+0.09388847, 0.11800314, 4.72295098e-003, 4.44378285e-003,
+-0.07984917, -0.03613737, 0.04490915, -0.02246483, 0.04681071,
+0.05240871, 0.02157206, -0.04603431, -0.01197929, -0.02748779,
+0.13621049, 0.08812155, -0.07802048, 4.86458559e-003, -0.01598836,
+0.01024450, -0.03463517, -0.02304239, -0.08692665, 0.06655128,
+0.05785803, -0.12640759, 0.02307472, 0.07337402, 0.07525434,
+0.04943763, -0.02241034, -0.09978238, 0.14487994, -0.06570521,
+-0.07855482, 0.02830222, -5.29603509e-004, -0.04669895,
+-0.11822784, -0.12246452, -0.15365660, -0.02969127, 0.08078201,
+0.13512598, 0.11505685, 0.04740673, 0.01376022, -0.05852978,
+-0.01537809, -0.05541119, 0.02491065, -0.02870786, 0.02760978,
+0.23836176, 0.22347429, 0.10306466, -0.06919070, -0.10132039,
+-0.20198342, -0.05040560, 0.27163076, 0.36987007, 0.34540465,
+0.29095781, 0.05649706, 0.04125737, 0.07505883, -0.02737836,
+-8.43431335e-003, 0.07368195, 0.01653876, -0.09402955,
+-0.09574359, 0.01474337, -0.07128561, -0.03460737, 0.11438941,
+0.13752601, -0.06385452, -0.06310338, 8.19548313e-003, 0.11622470,
+5.05133113e-003, -0.07602754, 0.06695660, 0.25723928, 0.09037900,
+0.28826267, 0.13165380, -0.05312614, -0.02137198, -0.03442232,
+-0.06255679, 0.03899667, 0.18391028, 0.26016650, 0.03374462,
+0.01860465, 0.19077586, 0.18160543, 3.43634398e-003, -0.03036782,
+0.19683038, 0.35378191, 0.24968483, -0.03222649, 0.28972381,
+0.43091634, 0.30778357, 0.02335266, -0.09877399, -6.85245218e-003,
+0.08945240, -0.08150686, 0.02792493, 0.24806842, 0.17338486,
+0.06231801, -0.10432383, -0.16653322, -0.13197899, -0.08531576,
+-0.19271527, -0.13536365, 0.22240199, 0.39219588, 0.26597717,
+-0.01231649, 0.01016179, 0.13379875, 0.12018334, -0.04852953,
+-0.07915270, 0.07036012, 3.87723115e-003, -0.06126805,
+-0.15015170, -0.11406515, -0.08556531, -0.07429333, -0.16115491,
+0.13214062, 0.25691369, 0.05697750, 0.06861912, -6.02903729e-003,
+-7.94562511e-003, 0.04799571, 0.06695165, -0.01926842, 0.06206308,
+0.13450983, -0.06381495, -2.98370165e-003, -0.03482971,
+7.53991678e-003, 0.03895611, 0.11464261, 0.01669971,
+8.27818643e-003, -7.49160210e-003, -0.11712562, -0.10650621,
+-0.10353880, -0.04994106, -7.65618810e-004, 0.03023767,
+-0.04759270, -0.07302686, -0.05825012, -0.13156348, -0.10639747,
+-0.19393684, -0.09973683, -0.07918908, 4.63177625e-004,
+-6.61382044e-004, 0.15853868, 0.08561199, -0.07660093,
+-0.08015265, -0.06164073, 0.01882577, -7.29908410e-004,
+0.06840892, 0.03843764, 0.20274927, 0.22028814, -5.26101235e-003,
+0.01452435, -0.06331623, 0.02865064, 0.05673740, 0.12171564,
+0.03837196, 0.03555467, -0.02662914, -0.10280123, -0.06526285,
+-0.11066351, -0.08988424, -0.10103678, 8.10526591e-003,
+5.95238712e-003, 0.02617721, -0.01705742, -0.10897956,
+-0.08004991, -0.11271993, -0.06185647, -0.06103712, 0.01597041,
+-0.05923606, 0.09410726, 0.22858568, 0.03263380, 0.06772990,
+-0.09003516, 0.01017870, 0.01931688, 0.08628357, -0.01430009,
+0.10954945, 0.16612452, -0.02434544, -0.03310068, -0.04236627,
+0.01212392, -6.15046406e-003, 0.06954194, 0.03015283, 0.01787957,
+0.02781667, -0.05561153, -8.96244217e-003, -0.04971489,
+0.07510284, 0.01775282, 0.05889897, -0.07981427, 0.03647643,
+-3.73833324e-003, -0.08894575, -0.06429435, -0.08068276,
+0.03567704, -0.07131936, -7.21910037e-003, -0.09566668,
+0.17886090, 0.14911725, 0.02070032, -0.05017120, -0.04992622,
+0.01570143, -0.09906903, 0.06456193, 0.15329507, 0.18820767,
+0.11689861, -0.01178513, -0.02225163, -0.01905318, 0.10271224,
+-7.27029052e-003, 0.11664233, 0.14796902, 0.07771893, 0.02400013,
+-0.05361797, -0.01972888, 0.01376177, 0.06740040, -0.06525395,
+0.05726178, -0.02404981, -0.14018567, -0.02074987, -0.04621970,
+-0.04688627, -0.01842059, 0.07722727, -0.04852883, 0.01529004,
+-0.19639495, 0.10817073, 0.03795860, -0.09435206, -0.07984378,
+-0.03383440, 0.11081333, 0.02237366, 0.12703256, 0.21613893,
+0.02918790, 4.66472283e-003, -0.10274266, -0.04854131,
+-3.46305710e-003, 0.08652268, 0.02251546, 0.09636052, 0.17180754,
+-0.09272388, 4.59174305e-004, -0.11723048, -0.12210111,
+-0.15547538, 0.07218186, -0.05297846, 0.03779940, 0.05150875,
+-0.03802310, 0.03870645, -0.15250699, -0.08696499, -0.02021560,
+0.04118926, -0.15177974, 0.01577647, 0.10249301, 7.50041893e-003,
+0.01721806, -0.06828983, -0.02397596, -0.06598977, -0.04317593,
+-0.08064980, 6.66632550e-003, 0.03333484, 0.07093620, 0.08231064,
+-0.06577903, -0.06698844, -0.06984019, -0.06508023, -0.14145090,
+-0.02393239, 0.06485303, 8.83263443e-003, 0.09251080, -0.07557579,
+-0.05067699, -0.09798748, -0.06703258, -0.14056294, 0.03245994,
+0.12554143, 0.01761621, 0.12980327, -0.04081950, -0.11906909,
+-0.14813015, -0.08376863, -0.12200681, 0.04988137, 0.05424247,
+-3.90952639e-003, 0.03255733, -0.12717837, -0.07461493,
+-0.05703964, -0.01736189, -0.08026433, -0.05433894, -0.01719359,
+0.02886275, 0.01772653, -0.09163518, 3.57789593e-003, -0.10129993,
+-0.02653764, -0.08131415, -0.03847986, -7.62157550e-004,
+0.06486648, 0.19675669, -0.04919156, -0.07059129, -0.04857785,
+-0.01042383, -0.08328653, 0.03660302, -0.03696846, 0.04969259,
+0.08241162, -0.12514858, -0.06122676, -0.03750202,
+6.52989605e-003, -0.10247213, 0.02568346, 4.51781414e-003,
+-0.03734229, -0.01131264, -0.05412074, 8.89345480e-004,
+-0.12388977, -0.05959237, -0.12418608, -0.06151643, -0.07310260,
+0.02441575, 0.07023528, -0.07548289, -7.57147965e-004,
+-0.09061348, -0.08112976, -0.06920306, 9.54394229e-003,
+-0.01219902, 1.21273217e-003, -8.88989680e-003, -0.08309301,
+-0.04552661, -0.10739882, -0.05691034, -0.13928030, 0.09027749,
+0.15123098, 0.03175976, 0.17763577, 3.29913251e-004, 0.05151888,
+-0.09844074, -0.09475287, -0.08571247, 0.16241577, 0.19336018,
+8.57454538e-003, 0.11474732, -0.01493934, 0.03352379, -0.08966240,
+-0.02322310, 0.02663568, 0.05448750, -0.03536883, -0.07210463,
+-0.06807277, -0.03121621, -0.05932408, -0.17282860, -0.15873498,
+-0.04956378, 0.01603377, -0.12385946, 0.13878587, 0.21468069,
+0.13510075, 0.20992437, 0.08845878, 0.08104013, 0.03754176,
+0.12173114, 0.11103114, 0.10643122, 0.13941477, 0.11640384,
+0.14786847, 0.01218238, 0.01160753, 0.03547940, 0.08794311,
+-0.01695384, -0.07692261, -0.08236158, 6.79194089e-003,
+-0.02458403, 0.13022894, 0.10953187, 0.09857773, 0.04735930,
+-0.04353498, -0.15173385, -0.17904443, -0.10450364, -0.13418166,
+-0.06633098, -0.03170381, -0.06839000, -0.11350126, -0.06983913,
+0.19083543, 0.17604128, 0.07730632, 0.10022651, 0.36428109,
+0.28291923, 0.12688625, 0.15942036, 0.14064661, -0.11201853,
+-0.13969108, -0.09088077, -0.14107047, 0.05117374,
+-2.63348082e-003, -0.10794610, -0.09715455, -0.05284977,
+0.01565668, 0.05031200, 0.07021113, -0.02963028, 0.01766960,
+0.08333644, -0.03211382, 4.90096770e-003, 0.05186674, -0.05045737,
+-0.09624767, -0.02525997, 0.06916669, 0.01213916, 0.05333899,
+-0.03443280, -0.10055527, -0.06291115, 5.42851724e-003,
+-6.30360236e-003, 0.02270257, -0.01769792, 0.03273688, 0.07746078,
+7.77099328e-003, 0.05041346, 0.01648103, -0.02321534, -0.09930186,
+-0.02293853, 0.02034990, -0.08324204, 0.08510064, -0.03732836,
+-0.06465405, -0.06086946, 0.13680504, -0.11469388, -0.03896406,
+-0.07142810, 2.67581246e-003, -0.03639632, -0.09849060,
+-0.11014334, 0.17489147, 0.17610909, -0.16091567, -0.07248894,
+0.01567141, 0.23742996, 0.07552249, -0.06270349, -0.07303379,
+0.25442186, 0.16903116, -0.08168741, -0.05913896, -0.03954096,
+6.81776879e-003, -0.05615319, -0.07303037, -0.12176382,
+0.12385108, 0.22084464, -0.05543206, -0.03310431, 0.05731593,
+0.19481890, 0.04016430, -0.06480758, -0.12353460, 0.18733442,
+-0.09631214, -0.11192076, 0.12404587, 0.15671748, 0.19256128,
+0.10895617, 0.03391477, -0.13032004, -0.05626907, -0.09025607,
+0.23485197, 0.27812332, 0.26725492, 0.07255980, 0.16565137,
+0.22388470, 0.07441066, -0.21003133, -0.08075339, -0.15031935,
+0.07023834, 0.10872041, 0.18156518, 0.20037253, 0.13571967,
+-0.11915682, -0.11131983, -0.18878011, 0.06074620, 0.20578890,
+0.12413109, 0.03930207, 0.29176015, 0.29502738, 0.27856228,
+-0.01803601, 0.16646385, 0.19268319, 0.01900682, 0.06026287,
+2.35868432e-003, 0.01558199, 0.02707230, 0.11383014, 0.12103992,
+0.03907350, 0.04637353, 0.09020995, 0.11919726, -3.63007211e-003,
+0.02220155, 0.10336831, 0.17351882, 0.12259731, 0.18983354,
+0.15736865, 0.01160725, -0.01690723, -9.69582412e-004, 0.07213813,
+0.01161613, 0.17864859, 0.24486147, 0.18208991, 0.20177495,
+0.05972528, -8.93934630e-003, -0.02316955, 0.14436610, 0.14114498,
+0.05520950, 0.06353590, -0.19124921, 0.10174713, 0.29414919,
+0.26448128, 0.09344960, 0.15284036, 0.19797507, 0.11369792,
+-0.12722753, -0.21396367, -0.02008235, -0.06566695, -0.01662150,
+-0.03937003, 0.04778343, 0.05017274, -0.02299062, -0.20208496,
+-0.06395898, 0.13721776, 0.22544557, 0.14888357, 0.08687132,
+0.27088094, 0.32206613, 0.09782200, -0.18523243, -0.17232181,
+-0.01041531, 0.04008654, 0.04199702, -0.08081299, -0.03755421,
+-0.04809646, -0.05222081, -0.21709201, -0.06622940, 0.02945281,
+-0.04600435, -0.05256077, -0.08432942, 0.02848100, 0.03490564,
+8.28621630e-003, -0.11051246, -0.11210597, -0.01998289,
+-0.05369405, -0.08869293, -0.18799506, -0.05436598, -0.05011634,
+-0.05419716, -0.06151857, -0.10827805, 0.04346735, 0.04016083,
+0.01520820, -0.12173316, -0.04880285, -0.01101406, 0.03250847,
+-0.06009551, -0.03082932, -0.02295134, -0.06856834, -0.08775249,
+-0.23793389, -0.09174541, -0.05538322, -0.04321031, -0.11874759,
+-0.04221844, -0.06070468, 0.01194489, 0.02608565, -0.03892140,
+-0.01643151, -0.02602034, -0.01305472, 0.03920100, -0.06514261,
+0.01126918, -6.27710763e-003, -0.02720047, -0.11133634,
+0.03300330, 0.02398472, 0.04079665, -0.10564448, 0.05966159,
+0.01195221, -0.03179441, -0.01692590, -0.06177841, 0.01841576,
+-5.51078189e-003, -0.06821765, -0.03191888, -0.09545476,
+0.03030550, -0.04896152, -0.02914624, -0.13283344, -0.04783419,
+6.07836898e-003, -0.01449538, -0.13358212, -0.09687774,
+-0.02813793, 0.01213498, 0.06650011, -0.02039067, 0.13356198,
+0.05986415, -9.12760664e-003, -0.18780160, -0.11992817,
+-0.06342237, 0.01229534, 0.07143231, 0.10713009, 0.11085765,
+0.06569190, -0.02956399, -0.16288325, -0.13993549, -0.01292515,
+0.03833013, 0.09130384, -0.05086257, 0.05617329, -0.03896667,
+-0.06282311, -0.11490010, -0.14264110, -0.04530499, 0.01598189,
+0.09167797, 0.08663294, 0.04885277, -0.05741219, -0.07565769,
+-0.17136464, -0.02619422, -0.02477579, 0.02679587, 0.11621952,
+0.08788391, 0.15520640, 0.04709549, 0.04504483, -0.10214074,
+-0.12293372, -0.04820546, -0.05484834, 0.05473754, 0.07346445,
+0.05577277, -0.08209965, 0.03462975, -0.20962234, -0.09324598,
+3.79481679e-003, 0.03617633, 0.16742408, 0.07058107, 0.10204960,
+-0.06795346, 3.22807301e-003, -0.12589309, -0.17496960,
+0.02078314, -0.07694324, 0.12184640, 0.08997164, 0.04793497,
+-0.11383379, -0.08046359, -0.25716835, -0.08080962,
+6.80711539e-003, -0.02930280, -3.04938294e-003, -0.11106286,
+-0.04628860, -0.07821649, 7.70127494e-003, -0.10247706,
+1.21042714e-003, 0.20573859, -0.03241005, 8.42972286e-003,
+0.01946464, -0.01197973, -0.14579976, 0.04233614,
+-4.14096704e-003, -0.06866436, -0.02431862, -0.13529138,
+1.25891645e-003, -0.11425111, -0.04303651, -0.01694815,
+0.05720210, -0.16040207, 0.02772896, 0.05498345, -0.15010567,
+0.01450866, 0.02350303, -0.04301004, -0.04951802, 0.21702233,
+-0.03159155, -0.01963303, 0.18232647, -0.03263875,
+-2.88476888e-003, 0.01587562, -1.94303901e-003, -0.07789494,
+0.04674156, -6.25576358e-003, 0.08925962, 0.21353747, 0.01254677,
+-0.06999976, -0.05931328, -0.01884327, -0.04306272, 0.11794136,
+0.03842728, -0.03907030, 0.05636114, -0.09766009, -0.02104000,
+8.72711372e-003, -0.02736877, -0.05112274, 0.16996814, 0.02955785,
+0.02094014, 0.08414304, -0.03335762, -0.03617457, -0.05808248,
+-0.08872101, 0.02927705, 0.27077839, 0.06075108, 0.07478261,
+0.15282831, -0.03908454, -0.05101782, -9.51998029e-003,
+-0.03272416, -0.08735625, 0.07633440, -0.07185312, 0.13841286,
+0.07812646, -0.12901451, -0.05488589, -0.05644578, -0.03290703,
+-0.11184757, 0.03751570, -0.05978153, -0.09155276, 0.05657315,
+-0.04328186, -0.03047933, -0.01413135, -0.10181040, -0.01384013,
+0.20132534, -0.01536873, -0.07641169, 0.05906778, -0.07833145,
+-0.01523801, -0.07502609, -0.09461885, -0.15013233, 0.16050665,
+0.09021381, 0.08473236, 0.03386267, -0.09147339, -0.09170618,
+-0.08498498, -0.05119187, -0.10431040, 0.01041618, -0.03064913,
+0.09340212, 0.06448522, -0.03881054, -0.04985436, -0.14794017,
+-0.05200112, -0.02144495, 0.04000821, 0.12420804, -0.01851651,
+-0.04116732, -0.11951703, -0.04879033, -0.08722515, -0.08454733,
+-0.10549165, 0.11251976, 0.10766345, 0.19201984, 0.06128913,
+-0.02734615, -0.08834923, -0.16999826, -0.03548348,
+-5.36092324e-003, 0.08297954, 0.07226378, 0.04194529, 0.04668673,
+8.73902347e-003, 0.06980139, 0.05652480, 0.05879445, 0.02477076,
+0.02451423, 0.12433673, 0.05600227, 0.06886370, 0.03863076,
+0.07459056, 0.02264139, 0.01495469, 0.06344220, 0.06945208,
+0.02931899, 0.11719371, 0.04527427, 0.03248192, 2.08271481e-003,
+0.02044626, 0.11403449, 0.04303892, 0.06444661, 0.04959024,
+0.08174094, 0.09240247, 0.04894639, 0.02252937, -0.01652530,
+0.07587013, 0.06064249, 0.13954395, 0.02772832, 0.07093039,
+0.08501238, 0.01701301, 0.09055722, 0.33421436, 0.20163782,
+0.09821030, 0.07951369, 0.08695120, -0.12757730, -0.13865978,
+-0.06610068, -0.10985506, 0.03406816, -0.01116336, -0.07281768,
+-0.13525715, -0.12844718, 0.08956250, 0.09171610, 0.10092317,
+0.23385370, 0.34489515, 0.09901748, 0.02002922, 0.12335990,
+0.07606190, -0.14899330, -0.15634622, -0.06494618, -0.01760547,
+0.03404277, -0.13208845, -0.12101169, -0.18294574, -0.16560709,
+0.02183887, -0.02752613, 0.01813638, 0.02000757, 0.01319924,
+0.08030242, 0.01220535, 2.98233377e-003, -0.01307070, 0.05970297,
+-0.05345284, -0.03381982, -9.87543724e-003, -0.06869387,
+0.03956730, -0.03108176, -0.05732809, 0.02172386, 0.04159765,
+2.62783933e-003, 0.04813229, 0.09358983, -8.18389002e-003,
+0.01724574, -0.02547474, -0.04967288, -0.02390376, 0.06640504,
+-0.06306566, 0.01137518, 0.05589378, -0.08237787, 0.02455001,
+-0.03059422, -0.08953978, 0.06851497, 0.07190268, -0.07610799,
+7.87237938e-003, -7.85830803e-003, 0.06006952, -0.01126728,
+-2.85743061e-003, -0.04772895, 0.01884944, 0.15005857,
+-0.06268821, -0.01989072, 0.01138399, 0.08760451, 0.03879007,
+-9.66926850e-003, -0.08012961, 0.06414555, -0.01362950,
+-0.09135523, 0.01755159, 0.04459474, 0.09650917, 0.05219948,
+-2.19440833e-003, -0.07037939, -0.01599054, 0.13103317,
+-0.02492603, -0.01032540, -0.02903307, 0.04489160, 0.05148086,
+0.01858173, -0.02919228, 0.08299296, -0.04590359, -0.15745632,
+-0.09068198, -0.02972453, 0.12985018, 0.22320485, 0.24261914,
+0.03642650, -0.05506422, 2.67413049e-003, -0.03834032, 0.06449424,
+0.03834866, 0.03816991, 0.25039271, 0.34212017, 0.32433882,
+0.18824573, -0.08599839, -0.17599408, -0.15317015, -0.09913155,
+-0.02856072, -0.05304699, -1.06437842e-003, -0.06641813,
+-0.07509298, 0.01463361, -0.07551918, -0.04510373,
+-8.44620075e-003, 0.01772176, 0.04068235, 0.20295307, 0.15719447,
+0.05712103, 0.26296997, 0.14657754, 0.01547317, -0.05052776,
+-0.03881342, -0.01437883, -0.04930177, 0.11719568, 0.24098417,
+0.26468599, 0.31698579, 0.10103608, -0.01096375, -0.01367013,
+0.17104232, 0.20065314, 2.67622480e-003, -0.01190034, 0.18301608,
+0.09459770, -0.06357619, -0.06473801, 0.01377906, -0.10032775,
+-0.06388740, 3.80393048e-003, 0.06206078, 0.10349120, 0.26804337,
+8.17918684e-003, -0.02314351, 9.34422202e-003, 0.09198381,
+0.03681326, -8.77339672e-003, -0.09662418, -0.02715708,
+0.13503517, 0.08962728, -6.57071499e-003, -0.03201199, 0.28510824,
+0.32095715, 0.18512695, -0.14230858, -0.14048551, -0.07181299,
+-0.08575408, -0.08661680, -0.17416079, 7.54326640e-004,
+0.05601677, 0.13585392, -0.04960437, -0.07708392, 0.10676333,
+-0.04407546, -0.07209078, 0.03663663, 0.28949317, 0.41127121,
+0.27431169, -0.06900328, -0.21474190, -0.15578632, -0.19555484,
+-0.15209621, -0.11269179, 0.07416003, 0.18991330, 0.26858172,
+0.01952259, 0.01017922, 0.02159843, -4.95165400e-003, -0.04368168,
+-0.12721671, -0.06673957, -0.11275250, 0.04413409, 0.05578312,
+0.03896771, 0.03566417, -0.05871816, -0.07388090, -0.17965563,
+-0.08570268, -0.15273231, -0.06022318, -0.06999847,
+-6.81510568e-003, 0.06294262, -6.54901436e-004, -0.01128654,
+-0.02289657, 0.04849290, 0.04140804, 0.23681939, 0.14545733,
+0.01989965, 0.12032662, 3.87463090e-003, -6.02597650e-003,
+-0.05919775, -0.03067224, -0.07787777, 0.10834727, 0.02153730,
+0.02765649, 0.03975543, -0.12182906, -0.04900113, -0.09940100,
+-0.06453611, -0.13757215, -0.03721382, 0.02827376, -0.04351249,
+0.01907038, -0.10284120, -0.05671160, -0.10760647, -0.09624009,
+-0.09565596, -0.01303654, 0.03080539, 0.01416511, 0.05846142,
+-5.42971538e-003, 0.06221476, -0.03320325, -0.06791797,
+-0.05791342, 0.12851369, 0.14990346, 0.03634374, 0.14262885,
+0.04330391, 0.05032569, -0.05631914, 0.01606137, 0.04387223,
+0.22344995, 0.15722635, -0.04693628, 0.03006579, -2.52882647e-003,
+0.05717621, -0.07529724, -0.02848588, -0.06868757,
+-4.51729307e-003, 0.06466042, -0.05935378, -0.04704857,
+-0.07363959, 0.04843248, -0.13421375, -0.09789340, -0.10255270,
+0.03509852, 0.04751543, -0.03822323, 0.09740467, 0.04762916,
+0.03940146, -0.08283259, 0.09552965, 0.05038739, 0.21258622,
+0.09646992, 0.03241193, 0.05167701, 0.04614570, 0.04330090,
+-0.02671840, -0.06259909, -0.02301898, 0.18829170, 0.10522786,
+0.04313190, 0.01670948, -0.08421925, 0.05911417, -0.10582602,
+-0.04855484, -0.08373898, 0.07775915, 0.03723533, -0.12047344,
+4.86345543e-003, -0.10520902, 0.06571782, -0.07528137,
+-0.03245651, -0.09869066, -0.02917477, -0.18293270, 0.14810945,
+9.24033765e-003, -0.04354914, 0.02266885, -0.11872729,
+-0.04016589, 0.02830229, 0.22539048, 0.20565644, 0.16701797,
+0.09019924, 0.01300652, 0.09760600, -0.03675831, -0.01935448,
+-0.06894835, 0.08077277, 0.19047537, 0.11312226, 0.04106043,
+-0.11187182, 0.04312806, -0.18548580, -0.11287174, -0.08794551,
+0.02078281, -0.15295486, 0.11806386, -0.01103218, -0.15971117,
+0.02153538, -0.05232147, -0.10835317, -0.13910367, 0.05920752,
+-0.10122602, 0.20174250, 0.09105796, -0.01881348, 0.09559010,
+-0.03725745, -0.09442931, -0.09763174, 0.05854454, 0.08287182,
+0.12919849, 0.08594352, -2.49806582e-003, 0.02398440,
+5.67950122e-003, -0.06296340, -0.12993270, 0.03855852, 0.05186560,
+0.10839908, -0.03380463, -0.12654832, -0.05399339, -0.07456800,
+-0.04736232, -0.10164231, 0.07496139, 0.08125214, 0.07656177,
+-0.04999603, -0.12823077, -0.07692395, -0.11317524, -0.09118655,
+-0.05695669, 0.10477209, 0.07468581, 0.01630048, -8.00961629e-003,
+-0.06582128, -0.04019095, -0.04682907, -0.01907842, -0.10997720,
+0.04911406, 0.02931030, 0.04197735, -0.05773980, -0.09670641,
+-0.03594951, -0.03402121, -0.07149299, -0.10566200, 0.10601286,
+0.06340689, -0.01518632, -5.96402306e-003, -0.07628012,
+-3.52779147e-003, -0.02683854, -0.10265494, -0.02680815,
+0.16338381, 0.03103515, 0.02296976, 0.01624348, -0.10831620,
+-0.02314233, -0.04789969, -0.05530700, -0.06461314, 0.10494506,
+0.04642856, -0.07592955, -0.06197905, -0.09042154, -0.01445521,
+-0.04297818, -0.11262015, -0.11430512, 0.03174541, -0.03677487,
+-0.02963996, -0.06610169, -0.13292049, -0.07059067, -0.08444111,
+-0.02640536, -0.07136250, 0.04559967, 0.01459980, 0.17989251,
+0.04435328, -0.12464730, -0.02871115, -0.10752209, -0.03393742,
+-0.03791408, 0.02548251, 0.01956050, 0.19245651, 0.13963254,
+-0.05904696, -0.07424626, -0.10411884, 1.54176133e-003,
+0.01797429, 0.13025844, 0.04547642, -0.05710349, -0.10697161,
+-0.13489437, -0.06515755, -0.06406886, -4.08572936e-003,
+-0.01336483, 0.04368737, -0.11259720, -0.05701635, -0.06469971,
+-0.08346602, -0.04166770, -0.05795543, -0.08247511, -0.05742628,
+0.08452254, -0.03350224, 0.13980860, 0.13252275, 0.07589617,
+0.07539988, 0.12155797, 0.19087289, 0.15050751, 0.21250245,
+0.14206800, 0.01298489, 0.07450245, 0.06559097, 0.01700557,
+0.04512971, 0.16950700, 0.10261577, 0.16389982, 0.05505059,
+-0.03453077, 0.08622462, 0.07935954, 0.03976260, 0.02036091,
+3.95744899e-003, 0.03267065, 0.15235919, 0.01297494, -0.08109194,
+0.01407558, 4.40693414e-003, -0.15157418, -0.11390478,
+-0.07487597, -7.81322457e-003, -0.02749545, -0.10181408,
+0.13755716, 0.14007211, 0.13482562, 0.27517235, 0.34251109,
+0.07639657, 0.07268607, 0.19823882, 0.16135791, -0.04186463,
+-0.12784107, -0.09846287, 0.03169041, 0.10974082, -0.15051922,
+-0.08916726, -0.07138767, -0.04153349, 6.25418453e-003,
+0.01266654, 0.10533249, 0.12749144, 0.15148053, 0.01498513,
+0.06305949, -0.01247123, -0.08778401, -0.08551880, -0.11955146,
+-0.08493572, -0.02901620, -0.02394859, -0.13427313, -0.11053200,
+-0.14413260, -0.15203285, 0.03972760, -3.72127310e-004,
+-0.04200919, 0.06105104, 0.01904975, -0.01106191,
+-7.27445772e-003, -0.01520341, 1.10228511e-003, -0.04949187,
+-0.08013099, 5.72071038e-003, 0.08415454, -0.06523152, 0.03664081,
+-0.02673042, -0.12066154, -0.03702074, 0.06006580, 0.01628682,
+-6.17772620e-003, 0.08192339, -3.41629819e-003, 0.02870512,
+0.05807141, 0.04959986, 0.04618251, -0.04901629, -0.10579574,
+0.02274442, 0.12070961, 2.23597488e-003, 0.09831765, -0.03019848,
+-0.11181970, -0.04961075, 0.02498928, -0.03714991, -0.01619653,
+0.02643486, -7.62964319e-003, -0.02882290, -0.06242594,
+-0.08439861, 0.07220893, 0.07263952, 0.01561574, 0.03091968,
+0.01708712, -0.03797151, -3.18561122e-003, 0.01624021,
+-0.02828573, 0.11284444, -1.32280716e-003, -0.07784860,
+-0.07209100, 0.03372242, 0.12154529, 0.02278104, -0.05275500,
+-0.01918484, 0.12989293, 0.05424401, 0.02333086, 0.04029022,
+0.12392918, 0.09495489, 0.09190340, 0.07935889, 8.76816828e-003,
+0.17148446, -8.51302687e-003, -0.08011249, -0.06796283,
+0.04884845, 0.01112272, -0.07835306, -1.14811445e-003,
+-0.03440760, 0.02845243, 0.07695542, -0.07069533, -0.01151784,
+-8.53884313e-003, -0.01662786, -0.04163864, 0.05400505,
+0.02859163, 0.02921852, 0.05003135, -6.85718050e-003, -0.01632611,
+0.07780217, 0.04042810, -0.01216440, 3.60914599e-003, -0.06322435,
+0.09516726, 0.12877031, -9.69162490e-003, 0.01031179, 0.05180895,
+-9.34659224e-003, -0.01644533, -0.04849347, -0.04343236,
+0.10514783, 0.08046635, -0.04615205, -0.03975486, -0.01485525,
+0.13096830, -0.01517950, -0.06571898, -0.04016372, 0.01849786,
+0.02439670, 0.08067258, 1.74824719e-003, 0.07053747, 0.08819518,
+-5.08352555e-003, -0.06550863, -0.08266170, -0.07780605,
+0.01453450, -0.08756890, 0.01096501, -8.71319138e-003, 0.10110464,
+0.02420769, -0.06708383, 0.02007811, 5.93133038e-003, 0.05398923,
+0.07538138, 0.02049227, 0.02242589, 0.04011070, -1.44875818e-003,
+-4.19115182e-003, 0.06367654, 0.02506934, 0.02434536, 0.05879405,
+-8.22952855e-003, -0.01242441, 0.04224926, -0.01754923,
+0.05958161, 0.03818886, -0.01830363, -0.04308917, -0.04422197,
+-0.02432721, 0.02264866, 2.03751423e-003, 0.01197031, 0.04439203,
+0.12169247, 0.03602713, -0.02599251, -1.98226492e-003, 0.02046336,
+-0.02639058, -1.91242550e-003, -0.09334669, -0.03595153,
+-9.88179818e-003, -0.06848445, -0.04666303, -0.09955736,
+-0.04206430, 0.02609075, 9.09005292e-003, -0.07138551,
+-4.22313227e-004, 0.01766645, 0.02756404, 0.01308276, 0.04052891,
+0.02387515, 0.05337298, 0.02500631, -0.04970853, -0.12467445,
+0.17604403, 0.12256411, -0.07512254, 8.70451052e-003, -0.05697548,
+-0.03626474, -8.76623299e-003, -0.01210897, -0.09451522,
+0.07490732, -0.02008001, -0.02681278, -0.06463405, -0.01517507,
+7.33757764e-003, 6.07147906e-003, -0.09316964, -0.04575328,
+0.13261597, 0.15424870, -0.01655918, -0.02772390, -0.05243644,
+-0.02356456, -0.02351753, -0.10211615, -0.12873036, 0.14549787,
+0.12519856, 4.38762689e-003, 0.02795992, 0.05170322, 0.09223596,
+0.05890015, 0.02376701, -0.02777346, 0.09506908, 0.02328936,
+-0.02319928, -0.03218696, -0.01527841, -0.01016694, -0.02674719,
+0.05137179, 0.01980666, 0.06544447, -0.01746171, 0.01026380,
+0.01561806, 7.97004555e-004, 0.07601810, 0.01907250, -0.03083035,
+-0.05987392, 0.09242783, 0.14555025, 0.01035827, 0.03092401,
+-0.09562709, -0.03802354, 0.02531144, 0.03079449, -0.07100715,
+0.03330721, -2.69116857e-003, 0.03167490, 0.05744999, 0.03259895,
+1.91266940e-003, 0.03194578, 0.07389776, 0.02198060, 0.07633314,
+0.03293105, -0.09103648, 0.04718142, 0.06102672, -0.01003063,
+5.85481385e-003, -0.01522574, 0.02323526, 0.10584345,
+4.35879454e-003, 0.06107873, 0.05868603, -0.03115531, 0.01214679,
+0.08567052, 3.93926632e-003, -0.02521488, -1.88425183e-003,
+0.02038053, -6.26854831e-004, 0.04897438, -0.04280585,
+-0.04819689, -0.04812867, -0.01451186, 0.05101469,
+-9.01125465e-003, -0.03333859, 0.03917955, 0.04196448, 0.04292135,
+0.02809529, 0.02999715, 0.04081348, 9.10039060e-003, 0.09703232,
+0.10379741, 0.02348725, -4.72756615e-003, 0.01027325, 0.10402658,
+0.12071823, 0.09817299, -0.02612033, 0.03638414, 0.05896405,
+0.04865025, 0.04793910, -0.03882321, -0.02962117, -0.01222268,
+0.04071597, 0.01922777, -0.02287866, 0.03328381, 0.01859092,
+0.09024994, 0.03804455, -0.01424510, 0.01953739, 0.02509617,
+-0.03390914, -0.05663941, -0.01641979, 0.05848591, 0.04639670,
+0.02092116, 0.12911791, 0.19918139, 0.07739855, -7.25806039e-003,
+0.04074838, 0.03183993, 1.39251316e-003, -0.01428625, 0.01865480,
+0.08529541, 0.13547510, 0.11189661, 0.03998901, 0.09575938,
+-0.02631102, -0.03458253, -0.04749985, -0.06070716,
+4.71884012e-003, 0.06445789, -0.02450038, -0.05483776,
+-0.04657237, -0.02030717, -0.03480766, -0.09397731, -0.06399718,
+-0.01804585, 5.62348310e-003, -6.64811488e-003, -0.06517869,
+6.96210237e-003, -0.01860148, -0.04245830, -0.05850367,
+-3.24417115e-003, 0.07700698, 0.11290991, 0.09923030, -0.02970599,
+0.05592411, 0.04813979, -0.09811195, -0.09357996, -0.03276114,
+0.05218338, 0.04141375, 3.92977800e-003, -0.05047480, 0.15960084,
+0.04612800, -0.03114098, -0.04650044, -0.03249795, -0.02425641,
+-0.04311355, 0.04307659, -0.09401883, -0.04742785, -0.01254499,
+-0.06598741, 3.41369561e-003, -0.05620445, -7.28127593e-003,
+-0.05998361, -0.03274450, -0.07376868, 3.19015374e-003,
+-0.07733069, 0.05815864, -0.02471071, 0.03850617, 0.13838784,
+0.15399861, 0.01731321, -0.01477586, 0.10393341, 0.05159833,
+-0.01945555, -0.03427503, -0.04867341, 0.09237480, 0.10732719,
+0.06071450, -0.01355071, 0.01844356, -0.03480803, -0.03796671,
+2.15628621e-004, -0.05440186, 0.01889855, -0.01443413,
+-0.02607902, -0.02938001, 0.02720689, -0.06228397, -0.02970936,
+-0.03426210, -0.10280876, -0.06739304, -0.05227850, 0.03360292,
+-0.11278441, -0.06966180, -0.13937433, 9.10932291e-003,
+2.52020749e-004, -4.07359656e-003, 0.12310639, 0.09343060,
+0.07302511, 0.03222093, 0.07532879, 0.03792387, -0.04985180,
+0.01804602, 0.02694195, 0.13481498, 0.04601225, 0.04106982,
+0.08511057, 0.12314661, 0.01320830, 0.05044121, -5.52943908e-003,
+-0.08992624, -0.02249301, -0.08181777, 0.06165213, -0.03256603,
+-0.01068920, -0.01323473, -0.11970232, -0.04616347, -0.12088681,
+-0.06762606, -0.08676834, -0.06434575, 0.01772529, 0.03469615,
+-0.10926618, 0.03013873, 0.14030397, 0.16130108, 0.17985588,
+0.11281928, 0.10530639, 0.08905948, 0.07733764, 0.06695238,
+0.02142088, 0.06438877, 0.09794453, 0.05745072, 0.02788557,
+0.02632830, 0.07985807, 4.24902979e-003, 8.47890321e-003,
+-0.02679466, -5.28812688e-003, -0.02162580, -0.07490715,
+-0.08251337, -0.02056576, -0.01026194, -1.15492963e-003,
+-5.75720915e-004, -0.07210591, -0.07320981, -0.04883312,
+-0.10897151, -0.07477258, -0.08867134, -0.09222437, -0.10924666,
+-0.10430276, 0.07953499, 0.02767959, 0.11393359, 0.18779543,
+0.03313421, 0.02143700, 0.05852016, -2.12067598e-003,
+-3.76984011e-003, 0.02774167, -0.03124610, 0.01465141, 0.01616004,
+-0.01391913, -0.04404102, -0.05444227, -0.14684731, -0.15016587,
+0.04509468, 1.29563001e-003, 0.01398350, 0.05610404, -0.04868806,
+-0.04776716, -8.16873740e-003, -2.30126386e-003, -0.02286313,
+0.11983398, -0.04703261, -0.08814441, -0.07585249, -0.10799607,
+-0.03232087, 0.01509786, -0.04843464, -0.03967846, 0.09589416,
+0.01352560, -0.01458119, 0.01050829, -0.03038946, 0.01608388,
+1.11975556e-003, -0.01250656, 2.86211423e-003, 0.04333691,
+-0.14603497, -0.01946543, -0.02327525, -0.01973944, 0.07944400,
+-0.02224544, -0.06701808, 0.03476532, 0.11505594, -0.02712801,
+-0.01665113, 0.06315716, -0.08205860, 0.07431999, 0.04915778,
+-0.04468752, -0.01490402, 0.07400476, -0.11650901, 0.05102430,
+0.04559118, -0.05916039, 0.08840760, -0.01587902, -0.14890194,
+0.07857784, 0.04710254, -0.05381983, -0.07331945, -0.03604643,
+0.15611970, 0.07649943, -0.05959348, -0.02776607, 0.11098688,
+0.03758875, -0.04446875, 0.04933187, 0.01345535, 0.06921103,
+0.07364785, 0.05518956, 0.02899585, 0.09375840, 0.10518434,
+-0.04420241, 0.01915282, -3.56386811e-003, 0.14586878, 0.10286101,
+-0.04360626, -0.12723237, 0.09076386, 0.11119842, -0.06035013,
+0.09674817, 0.08938243, 0.07065924, 0.02603180, 5.84815582e-003,
+-0.05922065, 0.12360309, 3.59695964e-003, 2.99844006e-003,
+0.03697936, 0.02043072, 0.04168725, 0.01025975, -0.01359980,
+-0.01600920, 0.02581056, 0.02329250, 2.98100687e-003, 0.01629762,
+0.06652115, 0.05855627, 0.01237463, -0.01297135, 0.01761587,
+0.05090865, 0.06549342, -0.04425945, 2.43203156e-003,
+3.07327788e-003, 0.06678630, -0.04303836, 0.01082393, -0.06476044,
+0.04077786, 0.12441979, 0.08237778, 0.07424165, 0.04065890,
+0.06905543, 0.09556347, 0.12724875, -0.02132082, 0.08514154,
+-0.04175328, -0.02666954, 0.01897836, 0.03317382, 9.45465732e-003,
+-0.01238974, -0.04242500, -0.01419479, -0.03545213, -0.02440874,
+0.08684119, 0.04212951, 0.02462858, -0.01104825, -5.01706870e-003,
+0.02968982, 0.02597476, -0.01568939, 0.04514892, 0.06974549,
+0.08670278, 0.06828108, 0.10238872, 0.05405957, 0.06548470,
+-0.03763957, 0.01366090, 0.07069602, 0.05363748, 0.04798120,
+0.11706422, 0.05466456, -0.01869259, 0.06344382, 0.03106543,
+0.08432506, -0.02061096, 0.03821088, -6.92190882e-003,
+6.40467042e-003, -0.01271779, 6.89014705e-005, 0.04541415,
+-0.01899539, -0.05020239, 0.03000903, 0.01090422, 4.52452758e-003,
+0.02573632, -0.02388454, -0.04200457, 1.72783900e-003,
+-0.05978370, -0.02720562, 0.06573715, 0.01154317, 0.01265615,
+0.07375994, -9.19828378e-003, -0.04914120, 0.02124831, 0.06455322,
+0.04372910, -0.03310043, 0.03605788, -6.78055827e-003,
+9.36202332e-003, 0.01747596, -0.06406314, -0.06812935, 0.08080816,
+-0.02778088, 0.02735260, 0.06393493, 0.06652229, 0.05676993,
+0.08640018, -7.59188086e-003, -0.02012847, -0.04741159,
+-0.01657069, -0.01624399, 0.05547778, -2.33309763e-003,
+0.01120033, 0.06141156, -0.06285004, -0.08732341, -0.09313398,
+-0.04267832, 5.57443965e-003, 0.04809862, 0.01773641,
+5.37361018e-003, 0.14842421, -0.06298012, -0.02935147, 0.11443478,
+-0.05034208, 5.65494271e-003, 0.02076526, -0.04577984,
+-0.04735741, 0.02961071, -0.09307127, -0.04417921, -0.04990027,
+-0.03940028, 0.01306016, 0.06267900, 0.03758737, 0.08460117,
+0.13858789, 0.04862388, -0.06319809, -0.05655516, 0.01885816,
+-0.03285607, 0.03371567, -0.07040928, -0.04514049, 0.01392166,
+0.08184422, -0.07230316, 0.02386871, 0.02184591, 0.02605764,
+-0.01033954, 9.29878280e-003, 7.67351175e-003, 0.15189242,
+0.02069071, -0.09738296, -0.08894105, -0.07768748, 0.02332268,
+-0.01778995, -0.03258888, -0.08180822, -0.08492987, 0.02290156,
+-0.11368170, -0.03554465, -0.04533844, -0.02861580, 0.06782424,
+0.01113123, 0.02453644, 0.12721945, 0.08084814, -0.03607795,
+0.01109122, 0.04803548, -0.03489929, 0.03399536, -0.05682014,
+8.59533902e-003, -4.27904585e-003, 0.03230887, -0.01300198,
+-0.01038137, -0.07930113, 8.33097473e-003, 0.02296994,
+-0.01306500, -0.01881626, 0.04413369, 0.05729880, -0.03761553,
+0.01942326, 1.64540811e-003, -0.03811319, 0.04190650, -0.14978096,
+-0.04514487, 0.01209545, -5.46460645e-003, -0.01647195,
+7.63064111e-003, -0.07494587, 0.08415288, 0.10020141, -0.01228561,
+0.06553826, 0.04554005, 0.07890417, 0.03041138, 0.01752007,
+0.09208256, -3.74419295e-004, 0.10549527, 0.04686913, 0.01894833,
+-0.02651412, -4.34682379e-003, 5.44942822e-003, 0.01444484,
+0.05882156, -0.03336544, 0.04603891, -0.10432546, 0.01923928,
+0.01842845, -0.01712168, -0.02222766, 0.04693324, -0.06202956,
+-0.01422159, 0.08732220, -0.07706107, 0.02661049, -0.04300238,
+-0.03092422, -0.03552184, -0.01886088, -0.04979934, 0.03906401,
+0.04608644, 0.04966111, 0.04275464, -0.04621769, -0.02653212,
+8.57011229e-003, 0.03839684, 0.05818764, 0.03880796,
+-2.76100676e-004, 0.03076511, -0.03266929, -0.05374557,
+0.04986527, -9.45429131e-003, 0.03582499, -2.64564669e-003,
+-1.07461517e-003, 0.02962313, -0.01483363, 0.03060869, 0.02448327,
+0.01845641, 0.03282966, -0.03534438, -0.01084059, -0.01119136,
+-1.85360224e-003, -5.94652840e-004, -0.04451817, 2.98327743e-003,
+0.06272484, -0.02152076, -3.05971340e-003, -0.05070828,
+0.01531762, 0.01282815, 0.05167150, 9.46266949e-003,
+-3.34558333e-003, 0.11442288, -0.03906701, -2.67325155e-003,
+0.03069184, -0.01134165, 0.02949462, 0.02879886, 0.03855566,
+-0.03450781, 0.09142872, -0.02156654, 0.06075062, -0.06220816,
+0.01944680, 6.68372354e-003, -0.06656796, 8.70784000e-003,
+0.03456013, 0.02434320, -0.13236357, -0.04177035, -0.02069627,
+0.01068112, 0.01505432, -0.07517391, -3.83571628e-003,
+-0.06298508, -0.02881260, -0.13101046, -0.07221562,
+-5.79945277e-003, -8.57300125e-003, 0.03782469, 0.02762164,
+0.04942456, -0.02936396, 0.09597211, 0.01921411, 0.06101191,
+-0.04787507, -0.01379578, -7.40224449e-003, -0.02220136,
+-0.01313756, 7.77558051e-003, 0.12296968, 0.02939998, 0.03594062,
+-0.07788624, -0.01133144, 3.99316690e-004, -0.06090347,
+-0.01122066, -4.68682544e-003, 0.07633100, -0.06748922,
+-0.05640298, -0.05265681, -0.01139122, -0.01624347, -0.04715714,
+-0.01099092, 0.01048561, 3.28499987e-003, -0.05810167,
+-0.07699911, -0.03330683, 0.04185145, 0.03478536, 0.02275165,
+0.02304766, 6.66040834e-003, 0.10968148, -5.93013782e-003,
+-0.04858336, -0.04203213, -0.09316786, -6.13074889e-003,
+-0.02544625, 0.01366201, 9.18555818e-003, -0.01846578,
+-0.05622401, -0.03989377, -0.07810296, 6.91275718e-003,
+0.05957597, -0.03901334, 0.01572002, -0.01193903,
+-6.89400872e-003, -0.03093356, -0.04136098, -0.01562869,
+-0.04604580, 0.02865234, -0.08678447, -0.03232484, -0.05364593,
+-0.01445016, -0.07003860, -0.08669746, -0.04520775, 0.04274122,
+0.03117515, 0.08175703, 0.01081109, 0.06379741, 0.06199206,
+0.02865988, 0.02360346, 0.06725410, -0.03248780, -9.37702879e-003,
+0.08265898, -0.02245839, 0.05125763, -0.01862395, 0.01973453,
+-0.01994494, -0.10770868, 0.03180375, 3.23935156e-003,
+-0.02142080, -0.04256190, 0.04760900, 0.04282863, 0.05635953,
+-0.01870849, 0.05540622, -0.03042666, 0.01455277, -0.06630179,
+-0.05843807, -0.03739681, -0.09739155, -0.03220233, -0.05620182,
+-0.10381401, 0.07400211, 4.20676917e-003, 0.03258535,
+2.14308966e-003, 0.05121966, -0.01274337, 0.02384761, 0.06335578,
+-0.07905591, 0.08375625, -0.07898903, -0.06508528, -0.02498444,
+0.06535810, 0.03970535, 0.04895468, -0.01169566, -0.03980601,
+0.05682293, 0.05925463, -0.01165808, -0.07936699, -0.04208954,
+0.01333987, 0.09051196, 0.10098671, -0.03974256, 0.01238771,
+-0.07501741, -0.03655440, -0.04301528, 0.09216860,
+4.63579083e-004, 0.02851115, 0.02142735, 1.28244064e-004,
+0.02879687, -0.08554889, -0.04838862, 0.08135369, -0.05756533,
+0.01413900, 0.03451880, -0.06619488, -0.03053130, 0.02961676,
+-0.07384635, 0.01135692, 0.05283910, -0.07778034, -0.02107482,
+-0.05511716, -0.13473752, 0.03030157, 0.06722020, -0.06218817,
+-0.05826827, 0.06254654, 0.02895772, -0.01664000, -0.03620280,
+-0.01612278, -1.46097376e-003, 0.14013411, -8.96181818e-003,
+-0.03250246, 3.38630192e-003, 2.64779478e-003, 0.03359732,
+-0.02411991, -0.04229729, 0.10666174, -6.66579151
diff --git a/samples/python2/peopledetect.py b/samples/python2/peopledetect.py
new file mode 100644
index 0000000000..730587e718
--- /dev/null
+++ b/samples/python2/peopledetect.py
@@ -0,0 +1,58 @@
+import numpy as np
+import cv2
+
+help_message = '''
+USAGE: peopledetect.py <image_names> ...
+
+Press any key to continue, ESC to stop. 
+'''
+
+def inside(r, q):
+    rx, ry, rw, rh = r
+    qx, qy, qw, qh = q
+    return rx > qx and ry > qy and rx + rw < qx + qw and ry + rh < qy + qh
+
+def draw_detections(img, rects, thickness = 1):
+    for x, y, w, h in rects:
+        # the HOG detector returns slightly larger rectangles than the real objects.
+        # so we slightly shrink the rectangles to get a nicer output.
+        pad_w, pad_h = int(0.15*w), int(0.05*h)
+        cv2.rectangle(img, (x+pad_w, y+pad_h), (x+w-pad_w, y+h-pad_h), (0, 255, 0), thickness)
+
+
+if __name__ == '__main__':
+    import sys
+    from glob import glob
+    import itertools as it
+
+    print help_message
+
+    # TODO should use built-in detector data
+    text = "".join(open('people_hog.txt').readlines()[1:])
+    data = np.fromstring(text, sep=',')
+    hog = cv2.HOGDescriptor()
+    hog.setSVMDetector(data)
+
+    for fn in it.chain(*map(glob, sys.argv[1:])):
+        print fn, ' - ',
+        try: 
+            img = cv2.imread(fn)
+        except:
+            print 'loading error'
+            continue
+
+        found = hog.detectMultiScale(img, winStride=(8,8), padding=(32,32), scale=1.05)
+        found_filtered = []
+        for ri, r in enumerate(found):
+            for qi, q in enumerate(found):
+                if ri != qi and inside(r, q):
+                    break
+            else:
+                found_filtered.append(r)
+        draw_detections(img, found)
+        draw_detections(img, found_filtered, 3)
+        print '%d (%d) found' % (len(found_filtered), len(found))
+        cv2.imshow('img', img)
+        ch = cv2.waitKey()
+        if ch == 27:
+            break
diff --git a/samples/python2/squares.py b/samples/python2/squares.py
new file mode 100644
index 0000000000..32d3c2db63
--- /dev/null
+++ b/samples/python2/squares.py
@@ -0,0 +1,39 @@
+import numpy as np
+import cv2
+
+
+def angle_cos(p0, p1, p2):
+    d1, d2 = p0-p1, p2-p1
+    return abs( np.dot(d1, d2) / np.sqrt( np.dot(d1, d1)*np.dot(d2, d2) ) )
+
+def find_squares(img):
+    img = cv2.GaussianBlur(img, (5, 5), 0)
+    squares = []
+    for gray in cv2.split(img):
+        for thrs in xrange(0, 255, 26):
+            if thrs == 0:
+                bin = cv2.Canny(gray, 0, 50, apertureSize=5)
+                bin = cv2.dilate(bin, None)
+            else:
+                retval, bin = cv2.threshold(gray, thrs, 255, cv2.THRESH_BINARY)
+            contours, hierarchy = cv2.findContours(bin, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+            for cnt in contours:
+                cnt_len = cv2.arcLength(cnt, True)
+                cnt = cv2.approxPolyDP(cnt, 0.02*cnt_len, True)
+                if len(cnt) == 4 and cv2.contourArea(cnt) > 1000 and cv2.isContourConvex(cnt):
+                    cnt = cnt.reshape(-1, 2)
+                    max_cos = np.max([angle_cos( cnt[i], cnt[(i+1) % 4], cnt[(i+2) % 4] ) for i in xrange(4)])
+                    if max_cos < 0.1:
+                        squares.append(cnt)
+    return squares
+
+if __name__ == '__main__':
+    from glob import glob
+    for fn in glob('../cpp/pic*.png'):
+        img = cv2.imread(fn)
+        squares = find_squares(img)
+        cv2.drawContours( img, squares, -1, (0, 255, 0), 3 )
+        cv2.imshow('squares', img)
+        ch = cv2.waitKey()
+        if ch == 27:
+            break
\ No newline at end of file
diff --git a/samples/python2/stereo_match.py b/samples/python2/stereo_match.py
new file mode 100644
index 0000000000..0bbcb81726
--- /dev/null
+++ b/samples/python2/stereo_match.py
@@ -0,0 +1,73 @@
+'''
+Simple example of stereo image matching and point cloud generation.
+
+Resulting .ply file cam be easily viewed using MeshLab (http://meshlab.sourceforge.net/)
+'''
+
+import numpy as np
+import cv2
+
+ply_header = '''ply
+format ascii 1.0
+element vertex %(vert_num)d
+property float x
+property float y
+property float z
+property uchar red
+property uchar green
+property uchar blue
+end_header
+'''
+
+def write_ply(fn, verts, colors):
+    verts = verts.reshape(-1, 3)
+    colors = colors.reshape(-1, 3)
+    verts = np.hstack([verts, colors])
+    with open(fn, 'w') as f:
+        f.write(ply_header % dict(vert_num=len(verts)))
+        np.savetxt(f, verts, '%f %f %f %d %d %d')
+
+
+if __name__ == '__main__':
+    print 'loading images...'
+    imgL = cv2.pyrDown( cv2.imread('../gpu/aloeL.jpg') )  # downscale images for faster processing
+    imgR = cv2.pyrDown( cv2.imread('../gpu/aloeR.jpg') )
+
+    # disparity range is tuned for 'aloe' image pair
+    window_size = 3
+    min_disp = 16
+    num_disp = 112-min_disp
+    stereo = cv2.StereoSGBM(minDisparity = min_disp, 
+        numDisparities = num_disp, 
+        SADWindowSize = window_size,
+        uniquenessRatio = 10,
+        speckleWindowSize = 100,
+        speckleRange = 32,
+        disp12MaxDiff = 1,
+        P1 = 8*3*window_size**2,
+        P2 = 32*3*window_size**2,
+        fullDP = False
+    )
+
+    print 'computing disparity...'
+    disp = stereo.compute(imgL, imgR).astype(np.float32) / 16.0
+    
+    print 'generating 3d point cloud...',
+    h, w = imgL.shape[:2]
+    f = 0.8*w                          # guess for focal length
+    Q = np.float32([[1, 0, 0, -0.5*w],
+                    [0,-1, 0,  0.5*h], # turn points 180 deg around x-axis, 
+                    [0, 0, 0,     -f], # so that y-axis looks up
+                    [0, 0, 1,      0]])
+    points = cv2.reprojectImageTo3D(disp, Q)
+    colors = cv2.cvtColor(imgL, cv2.COLOR_BGR2RGB)
+    mask = disp > disp.min()
+    out_points = points[mask]
+    out_colors = colors[mask]
+    out_fn = 'out.ply'
+    write_ply('out.ply', out_points, out_colors)
+    print '%s saved' % 'out.ply'
+
+    cv2.imshow('left', imgL)
+    cv2.imshow('disparity', (disp-min_disp)/num_disp)
+    cv2.waitKey()
\ No newline at end of file
diff --git a/samples/python2/turing.py b/samples/python2/turing.py
new file mode 100644
index 0000000000..f04c5a1ef7
--- /dev/null
+++ b/samples/python2/turing.py
@@ -0,0 +1,60 @@
+'''
+Multiscale Turing Patterns generator.
+Inspired by http://www.jonathanmccabe.com/Cyclic_Symmetric_Multi-Scale_Turing_Patterns.pdf
+'''
+
+import numpy as np
+import cv2
+import cv2.cv as cv
+from common import draw_str
+import getopt, sys
+from itertools import count
+
+help_message = '''
+USAGE: turing.py [-o <output.avi>]
+
+Press ESC to stop.
+'''
+print help_message
+
+w, h = 512, 512
+
+args, args_list = getopt.getopt(sys.argv[1:], 'o:', [])
+args = dict(args)
+out = None
+if '-o' in args:
+    fn = args['-o']
+    out = cv2.VideoWriter(args['-o'], cv.CV_FOURCC(*'DIB '), 30.0, (w, h), False)
+    print 'writing %s ...' % fn
+
+a = np.zeros((h, w), np.float32)
+cv2.randu(a, np.array([0]), np.array([1]))
+
+def process_scale(a_lods, lod):
+    d = a_lods[lod] - cv2.pyrUp(a_lods[lod+1])
+    for i in xrange(lod):
+        d = cv2.pyrUp(d)
+    v = cv2.GaussianBlur(d*d, (3, 3), 0)
+    return np.sign(d), v
+    
+scale_num = 6
+for frame_i in count():
+    a_lods = [a]
+    for i in xrange(scale_num):
+        a_lods.append(cv2.pyrDown(a_lods[-1])) 
+    ms, vs = [], []
+    for i in xrange(1, scale_num):
+        m, v = process_scale(a_lods, i)
+        ms.append(m)
+        vs.append(v)
+    mi = np.argmin(vs, 0)
+    a += np.choose(mi, ms) * 0.025
+    a = (a-a.min()) / a.ptp()
+
+    if out:
+        out.write(a)
+    vis = a.copy()
+    draw_str(vis, (20, 20), 'frame %d' % frame_i)
+    cv2.imshow('a', vis)
+    if cv2.waitKey(5) == 27:
+        break
diff --git a/samples/python2/video.py b/samples/python2/video.py
index 12bc931357..d18ee82d07 100644
--- a/samples/python2/video.py
+++ b/samples/python2/video.py
@@ -60,6 +60,7 @@ class Chess(VideoSynthBase):
                         [0.0,0.0,      1.0]])
 
         self.dist_coef = np.float64([-0.2, 0.1, 0, 0])
+        self.t = 0
 
     def draw_quads(self, img, quads, color = (0, 255, 0)):
         img_quads = cv2.projectPoints(quads.reshape(-1, 3), self.rvec, self.tvec, self.K, self.dist_coef) [0]
@@ -68,7 +69,8 @@ class Chess(VideoSynthBase):
             cv2.fillConvexPoly(img, np.int32(q*4), color, cv2.CV_AA, shift=2)
 
     def render(self, dst):
-        t = clock()
+        t = self.t
+        self.t += 1.0/30.0
         
         sx, sy = self.grid_size
         center = np.array([0.5*sx, 0.5*sy, 0.0])
diff --git a/samples/python2/watershed.py b/samples/python2/watershed.py
new file mode 100644
index 0000000000..cb0cb8dcb1
--- /dev/null
+++ b/samples/python2/watershed.py
@@ -0,0 +1,63 @@
+import numpy as np
+import cv2
+from common import Sketcher
+
+help_message = '''
+  USAGE: watershed.py [<image>]
+
+  Use keys 1 - 7 to switch marker color
+  SPACE - update segmentation
+  r     - reset
+  a     - switch autoupdate
+  ESC   - exit
+
+'''
+
+class App:
+    def __init__(self, fn):
+        self.img = cv2.imread(fn)
+        h, w = self.img.shape[:2]
+        self.markers = np.zeros((h, w), np.int32)
+        self.markers_vis = self.img.copy()
+        self.cur_marker = 1
+        self.colors = np.int32( list(np.ndindex(2, 2, 2)) ) * 255
+
+        self.auto_update = True
+        self.sketch = Sketcher('img', [self.markers_vis, self.markers], self.get_colors)
+        
+    def get_colors(self):
+        return map(int, self.colors[self.cur_marker]), self.cur_marker
+
+    def watershed(self):
+        m = self.markers.copy()
+        cv2.watershed(self.img, m)
+        overlay = self.colors[np.maximum(m, 0)]
+        vis = cv2.addWeighted(self.img, 0.5, overlay, 0.5, 0.0, dtype=cv2.CV_8UC3)
+        cv2.imshow('watershed', vis)
+
+    def run(self):
+        while True:
+            ch = cv2.waitKey(50)
+            if ch == 27:
+                break
+            if ch >= ord('1') and ch <= ord('7'):
+                self.cur_marker = ch - ord('0')
+                print 'marker: ', self.cur_marker
+            if ch == ord(' ') or (self.sketch.dirty and self.auto_update):
+                self.watershed()
+                self.sketch.dirty = False
+            if ch in [ord('a'), ord('A')]:
+                self.auto_update = not self.auto_update
+                print 'auto_update if', ['off', 'on'][self.auto_update]
+            if ch in [ord('r'), ord('R')]:
+                self.markers[:] = 0
+                self.markers_vis[:] = self.img
+                self.sketch.show()
+
+
+if __name__ == '__main__':
+    import sys
+    try: fn = sys.argv[1]
+    except: fn = '../cpp/fruits.jpg'
+    print help_message
+    App(fn).run()