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
index 9779ef85bf..32e2598c27 100644
--- a/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java
+++ b/modules/java/android_test/src/org/opencv/test/calib3d/Calib3dTest.java
@@ -4,6 +4,7 @@ import org.opencv.calib3d.Calib3d;
 import org.opencv.core.Core;
 import org.opencv.core.CvType;
 import org.opencv.core.Mat;
+import org.opencv.core.MatOfDouble;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.MatOfPoint3f;
 import org.opencv.core.Point;
@@ -174,15 +175,17 @@ public class Calib3dTest extends OpenCVTestCase {
 
     public void testFindChessboardCornersMatSizeMat() {
         Size patternSize = new Size(9, 6);
-        Calib3d.findChessboardCorners(grayChess, patternSize, dst);
-        assertTrue(!dst.empty());
+        MatOfPoint2f corners = new MatOfPoint2f();
+        Calib3d.findChessboardCorners(grayChess, patternSize, corners);
+        assertTrue(!corners.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
+        MatOfPoint2f corners = new MatOfPoint2f();
+        Calib3d.findChessboardCorners(grayChess, patternSize, corners, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
                 + Calib3d.CALIB_CB_FAST_CHECK);
-        assertTrue(!dst.empty());
+        assertTrue(!corners.empty());
     }
 
     public void testFindCirclesGridDefaultMatSizeMat() {
@@ -515,7 +518,7 @@ public class Calib3dTest extends OpenCVTestCase {
 
         Mat rvec = new Mat();
         Mat tvec = new Mat();
-        Calib3d.solvePnP(points3d, points2d, intrinsics, new Mat(), rvec, tvec);
+        Calib3d.solvePnP(points3d, points2d, intrinsics, new MatOfDouble(), rvec, tvec);
 
         Mat truth_rvec = new Mat(3, 1, CvType.CV_64F);
         truth_rvec.put(0, 0, 0, Math.PI / 2, 0);
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
index 21494a4a6f..128d453f27 100644
--- a/modules/java/android_test/src/org/opencv/test/core/CoreTest.java
+++ b/modules/java/android_test/src/org/opencv/test/core/CoreTest.java
@@ -1284,14 +1284,14 @@ public class CoreTest extends OpenCVTestCase {
         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));
-        MatOfInt fromTo = new MatOfInt(1, new int[]
-        	  { 3, 0,
+        MatOfInt fromTo = new MatOfInt(
+        		3, 0,
                 3, 1,
                 2, 2,
                 0, 3,
                 2, 4,
                 1, 5,
-                0, 6 }
+                0, 6
         );
 
         Core.mixChannels(src, dst, fromTo);
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
index d8f8750961..1c22a77e1b 100644
--- a/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingLUTDescriptorMatcherTest.java
+++ b/modules/java/android_test/src/org/opencv/test/features2d/BruteForceHammingLUTDescriptorMatcherTest.java
@@ -189,9 +189,11 @@ public class BruteForceHammingLUTDescriptorMatcherTest extends OpenCVTestCase {
 
         matcher.match(query, train, matches);
 
+        /*
         OpenCVTestRunner.Log("matches found: " + matches.size());
         for (DMatch m : matches.toArray())
             OpenCVTestRunner.Log(m.toString());
+        */
 
         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
     }
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
index 5fecf27a0e..c391310fcb 100644
--- a/modules/java/android_test/src/org/opencv/test/imgproc/ImgprocTest.java
+++ b/modules/java/android_test/src/org/opencv/test/imgproc/ImgprocTest.java
@@ -9,6 +9,7 @@ import org.opencv.core.CvType;
 import org.opencv.core.Mat;
 import org.opencv.core.MatOfFloat;
 import org.opencv.core.MatOfInt;
+import org.opencv.core.MatOfInt4;
 import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Point;
@@ -242,9 +243,9 @@ public class ImgprocTest extends OpenCVTestCase {
 
     public void testCalcBackProject() {
         List<Mat> images = Arrays.asList(grayChess);
-        MatOfInt channels = new MatOfInt(1, new int[]{0});
-        MatOfInt histSize = new MatOfInt(1, new int[]{10});
-        MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
+        MatOfInt channels = new MatOfInt(0);
+        MatOfInt histSize = new MatOfInt(10);
+        MatOfFloat ranges = new MatOfFloat(0f, 256f);
 
         Mat hist = new Mat();
         Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
@@ -259,9 +260,9 @@ public class ImgprocTest extends OpenCVTestCase {
 
     public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() {
         List<Mat> images = Arrays.asList(gray128);
-        MatOfInt channels = new MatOfInt(1, new int[]{0});
-        MatOfInt histSize = new MatOfInt(1, new int[]{10});
-        MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
+        MatOfInt channels = new MatOfInt(0);
+        MatOfInt histSize = new MatOfInt(10);
+        MatOfFloat ranges = new MatOfFloat(0f, 256f);
         Mat hist = new Mat();
 
         Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
@@ -276,9 +277,9 @@ public class ImgprocTest extends OpenCVTestCase {
 
     public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2d() {
         List<Mat> images = Arrays.asList(gray255, gray128);
-        MatOfInt channels = new MatOfInt(1, 0, 1);
-        MatOfInt histSize = new MatOfInt(1, 10, 10);
-        MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
+        MatOfInt channels = new MatOfInt(0, 1);
+        MatOfInt histSize = new MatOfInt(10, 10);
+        MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
         Mat hist = new Mat();
 
         Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
@@ -293,9 +294,9 @@ public class ImgprocTest extends OpenCVTestCase {
 
     public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
         List<Mat> images = Arrays.asList(gray255, gray128);
-        MatOfInt channels = new MatOfInt(1, 0, 1);
-        MatOfInt histSize = new MatOfInt(1, 10, 10);
-        MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
+        MatOfInt channels = new MatOfInt(0, 1);
+        MatOfInt histSize = new MatOfInt(10, 10);
+        MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
         Mat hist = new Mat();
 
         Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, true);
@@ -382,27 +383,67 @@ public class ImgprocTest extends OpenCVTestCase {
     }
 
     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);
+    	MatOfPoint points = new MatOfPoint(
+    	        new Point(20, 0), 
+    	        new Point(40, 0),
+    	        new Point(30, 20),
+    	        new Point(0,  20),
+    	        new Point(20, 10),
+    	        new Point(30, 10)
+    	);
 
         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);
+        MatOfPoint expHull = new MatOfPoint(
+        		new Point(40, 0),
+        		new Point(30, 20),
+        		new Point(0,  20),
+        		new Point(20, 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);
+    	MatOfPoint points = new MatOfPoint(
+    			new Point(2, 0),
+    			new Point(4, 0),
+    			new Point(3, 2),
+    			new Point(0, 2),
+    			new Point(2, 1),
+    			new Point(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);
+        MatOfPoint expHull = new MatOfPoint(
+        		new Point(0, 2),
+        		new Point(3, 2),
+        		new Point(4, 0),
+        		new Point(2, 0)
+        );
         assertMatEqual(expHull, dst, EPS);
     }
+    
+    public void testConvexityDefects() {
+    	MatOfPoint points = new MatOfPoint(
+    	        new Point(20, 0), 
+    	        new Point(40, 0),
+    	        new Point(30, 20),
+    	        new Point(0,  20),
+    	        new Point(20, 10),
+    	        new Point(30, 10)
+    	);
+
+        MatOfPoint hull = new MatOfPoint();
+        Imgproc.convexHull(points, hull, false, false);
+        
+        MatOfInt4 convexityDefects = new MatOfInt4();
+        Imgproc.convexityDefects(points, hull, convexityDefects);
+        
+        assertMatEqual(new MatOfInt4(3, 0, 5, 3620), convexityDefects);
+    }
 
     public void testCopyMakeBorderMatMatIntIntIntIntInt() {
         Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
@@ -1277,11 +1318,11 @@ public class ImgprocTest extends OpenCVTestCase {
     }
 
     public void testIsContourConvex() {
-        MatOfPoint2f contour1 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
+        MatOfPoint contour1 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
 
         assertFalse(Imgproc.isContourConvex(contour1));
 
-        MatOfPoint2f contour2 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
+        MatOfPoint contour2 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
 
         assertTrue(Imgproc.isContourConvex(contour2));
     }
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
index 2b176b7ce1..22efa06fe1 100644
--- a/modules/java/android_test/src/org/opencv/test/imgproc/Subdiv2DTest.java
+++ b/modules/java/android_test/src/org/opencv/test/imgproc/Subdiv2DTest.java
@@ -1,6 +1,6 @@
 package org.opencv.test.imgproc;
 
-import org.opencv.core.MatOfFloat;
+import org.opencv.core.MatOfFloat6;
 import org.opencv.core.Point;
 import org.opencv.core.Rect;
 import org.opencv.imgproc.Subdiv2D;
@@ -50,7 +50,7 @@ public class Subdiv2DTest extends OpenCVTestCase {
     	s2d.insert( new Point(20, 10) );
     	s2d.insert( new Point(20, 20) );
     	s2d.insert( new Point(10, 20) );
-    	MatOfFloat triangles = new MatOfFloat();
+    	MatOfFloat6 triangles = new MatOfFloat6();
     	s2d.getTriangleList(triangles);
     	assertEquals(10, triangles.rows());
     	/*
diff --git a/modules/java/gen_java.py b/modules/java/gen_java.py
index 2b4fa5a985..3a4fcf97ba 100644
--- a/modules/java/gen_java.py
+++ b/modules/java/gen_java.py
@@ -203,22 +203,24 @@ type_dict = {
     #"vector_Point3d"  : { "j_type" : "MatOfPoint3d", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3d> %(n)s", "suffix" : "J" },
     "vector_KeyPoint" : { "j_type" : "MatOfKeyPoint", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<KeyPoint> %(n)s", "suffix" : "J" },
     "vector_DMatch"   : { "j_type" : "MatOfDMatch", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<DMatch> %(n)s", "suffix" : "J" },
-    "vector_Rect"     : { "j_type" : "MatOfRect", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Rect> %(n)s", "suffix" : "J" },
-    "vector_uchar"    : { "j_type" : "MatOfByte", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<uchar> %(n)s", "suffix" : "J" },
-    "vector_char"     : { "j_type" : "MatOfByte", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<char> %(n)s", "suffix" : "J" },
-    "vector_int"      : { "j_type" : "MatOfInt", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<int> %(n)s", "suffix" : "J" },
-    "vector_float"    : { "j_type" : "MatOfFloat", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<float> %(n)s", "suffix" : "J" },
+    "vector_Rect"     : { "j_type" : "MatOfRect",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Rect> %(n)s", "suffix" : "J" },
+    "vector_uchar"    : { "j_type" : "MatOfByte",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<uchar> %(n)s", "suffix" : "J" },
+    "vector_char"     : { "j_type" : "MatOfByte",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<char> %(n)s", "suffix" : "J" },
+    "vector_int"      : { "j_type" : "MatOfInt",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<int> %(n)s", "suffix" : "J" },
+    "vector_float"    : { "j_type" : "MatOfFloat",  "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<float> %(n)s", "suffix" : "J" },
     "vector_double"   : { "j_type" : "MatOfDouble", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<double> %(n)s", "suffix" : "J" },
-    "vector_Vec4f"    : { "j_type" : "MatOfFloat", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec4f> %(n)s", "suffix" : "J" },
-    "vector_Vec6f"    : { "j_type" : "MatOfFloat", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec6f> %(n)s", "suffix" : "J" },
+    "vector_Vec4i"    : { "j_type" : "MatOfInt4",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec4i> %(n)s", "suffix" : "J" },
+    "vector_Vec4f"    : { "j_type" : "MatOfFloat4",  "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec4f> %(n)s", "suffix" : "J" },
+    "vector_Vec6f"    : { "j_type" : "MatOfFloat6",  "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Vec6f> %(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_Mat"      : { "j_type" : "List<Mat>",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Mat> %(n)s", "suffix" : "J" },
 
     "vector_vector_KeyPoint": { "j_type" : "List<MatOfKeyPoint>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<KeyPoint> > %(n)s" },
     "vector_vector_DMatch"  : { "j_type" : "List<MatOfDMatch>",   "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<DMatch> > %(n)s" },
     "vector_vector_char"    : { "j_type" : "List<MatOfByte>",     "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<char> > %(n)s" },
     "vector_vector_Point"   : { "j_type" : "List<MatOfPoint>",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point> > %(n)s" },
     "vector_vector_Point2f" : { "j_type" : "List<MatOfPoint2f>",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point2f> > %(n)s" },
+    "vector_vector_Point3f" : { "j_type" : "List<MatOfPoint3f>",    "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point3f> > %(n)s" },
 
     "Mat"     : { "j_type" : "Mat", "jn_type" : "long", "jn_args" : (("__int64", ".nativeObj"),),
                   "jni_var" : "Mat& %(n)s = *((Mat*)%(n)s_nativeObj)",
@@ -505,8 +507,10 @@ func_arg_fix = {
         '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', },
+        'solvePnP' : { 'objectPoints' : 'vector_Point3f', 'imagePoints' : 'vector_Point2f',
+                       'distCoeffs' : 'vector_double' },
+        'solvePnPRansac' : { 'objectPoints' : 'vector_Point3f', 'imagePoints' : 'vector_Point2f',
+                             'distCoeffs' : 'vector_double' },
         'calcOpticalFlowPyrLK' : { 'prevPts' : 'vector_Point2f', 'nextPts' : 'vector_Point2f',
                                    'status' : 'vector_uchar', 'err' : 'vector_float', },
         'fitEllipse' : { 'points' : 'vector_Point2f', },
@@ -526,8 +530,14 @@ func_arg_fix = {
         'meanStdDev' : {'mean' : 'vector_double', 'stddev' : 'vector_double'},
         'drawContours' : {'contours' : 'vector_vector_Point'},
         'findContours' : {'contours' : 'vector_vector_Point'},
-        'convexityDefects' : {'contour' : 'vector_Point'},
-        'isContourConvex' : { 'contour' : 'vector_Point2f', },
+        'convexityDefects' : {'contour' : 'vector_Point', 'convexityDefects' : 'vector_Vec4i'},
+        'isContourConvex' : { 'contour' : 'vector_Point', },
+        'convexHull' : {'points' : 'vector_Point'},
+        'projectPoints' : { 'objectPoints' : 'vector_Point3f', 'imagePoints' : 'vector_Point2f',
+                            'distCoeffs' : 'vector_double' },
+        'initCameraMatrix2D' : {'objectPoints' : 'vector_vector_Point3f', 'imagePoints' : 'vector_vector_Point2f', },
+        'findChessboardCorners' : { 'corners' : 'vector_Point2f' },
+        'drawChessboardCorners' : { 'corners' : 'vector_Point2f' },
     }, # '', i.e. no class
 } # func_arg_fix
 
@@ -903,15 +913,22 @@ extern "C" {
 
     def get_imports(self, scope_classname, ctype):
         imports = self.classes[scope_classname or self.Module].imports
+        if ctype.startswith('vector_vector'):
+            imports.add("org.opencv.core.Mat")
+            imports.add("java.util.List")
+            imports.add("org.opencv.utils.Converters")
+            self.get_imports(scope_classname, ctype.replace('vector_vector', 'vector'))
+            return
         if ctype.startswith('vector'):
             imports.add("org.opencv.core.Mat")
             if type_dict[ctype]['j_type'].startswith('MatOf'):
                 imports.add("org.opencv.core." + type_dict[ctype]['j_type'])
-                return #TMP
+                return
             else:
                 imports.add("java.util.List")
                 imports.add("org.opencv.utils.Converters")
-            ctype = ctype.replace('vector_', '')
+                self.get_imports(scope_classname, ctype.replace('vector_', ''))
+                return
         j_type = ''
         if ctype in type_dict:
             j_type = type_dict[ctype]['j_type']
@@ -919,6 +936,7 @@ extern "C" {
             imports.add("org.opencv.core." + j_type)
         if j_type == 'String':
             imports.add("java.lang.String")
+        return
 
 
 
@@ -1083,13 +1101,7 @@ extern "C" {
                 tail = ")"
                 j_type = type_dict[ret_type]["j_type"]
                 if j_type.startswith('MatOf'):
-                    ret_val += "new " + j_type + "("
-                    m_t  = re.match('vector_(\w+)', ret_type)
-                    m_ch = re.match('vector_Vec(\d+)', ret_type)
-                    if m_ch:
-                        ret_val += m_ch.group(1) +  ', '
-                    elif m_t.group(1) in ('char', 'uchar', 'int', 'float', 'double'):
-                        ret_val += '1, '
+                    ret_val += j_type + ".fromNativeAddr("
                 else:
                     ret_val = "Mat retValMat = new Mat("
                     j_prologue.append( j_type + ' retVal = new Array' + j_type+'();')
diff --git a/modules/java/src/cpp/converters.cpp b/modules/java/src/cpp/converters.cpp
index 7d7b092c68..380ed3810c 100644
--- a/modules/java/src/cpp/converters.cpp
+++ b/modules/java/src/cpp/converters.cpp
@@ -281,6 +281,32 @@ void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt)
     }
 }
 
+void Mat_to_vector_vector_Point2f(Mat& mat, vector< vector< Point2f > >& 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<Point2f> vpt;
+        Mat_to_vector_Point2f(vm[i], vpt);
+        vv_pt.push_back(vpt);
+    }
+}
+
+void Mat_to_vector_vector_Point3f(Mat& mat, vector< vector< Point3f > >& 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<Point3f> vpt;
+        Mat_to_vector_Point3f(vm[i], vpt);
+        vv_pt.push_back(vpt);
+    }
+}
+
 #ifdef HAVE_OPENCV_FEATURES2D
 void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp)
 {
@@ -361,6 +387,19 @@ void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat)
     vector_Mat_to_Mat(vm, mat);
 }
 
+void vector_vector_Point_to_Mat(vector< vector< Point > >& 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_Point_to_Mat(vv_pt[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;
@@ -374,19 +413,24 @@ void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat)
     vector_Mat_to_Mat(vm, mat);
 }
 
-void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat)
+void vector_vector_Point3f_to_Mat(vector< vector< Point3f > >& 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_Point_to_Mat(vv_pt[i], m);
+        vector_Point3f_to_Mat(vv_pt[i], m);
         vm.push_back(m);
     }
     vector_Mat_to_Mat(vm, mat);
 }
 
+void vector_Vec4i_to_Mat(vector<Vec4i>& v_vec, Mat& mat)
+{
+    mat = Mat(v_vec, true);
+}
+
 void vector_Vec4f_to_Mat(vector<Vec4f>& 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
index b1105ca1d8..9550defc47 100644
--- a/modules/java/src/cpp/converters.h
+++ b/modules/java/src/cpp/converters.h
@@ -37,6 +37,7 @@ 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_Vec4i_to_Mat(std::vector<cv::Vec4i>& v_vec, 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);
 
@@ -63,6 +64,10 @@ void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >&
 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);
 void vector_vector_Point_to_Mat(std::vector< std::vector< cv::Point > >& vv_pt, cv::Mat& mat);
 
+void Mat_to_vector_vector_Point2f(cv::Mat& mat, std::vector< std::vector< cv::Point2f > >& vv_pt);
+void vector_vector_Point2f_to_Mat(std::vector< std::vector< cv::Point2f > >& vv_pt, cv::Mat& mat);
+
+void Mat_to_vector_vector_Point3f(cv::Mat& mat, std::vector< std::vector< cv::Point3f > >& vv_pt);
+void vector_vector_Point3f_to_Mat(std::vector< std::vector< cv::Point3f > >& vv_pt, cv::Mat& mat);
diff --git a/modules/java/src/java/core+MatOfByte.java b/modules/java/src/java/core+MatOfByte.java
index dbd489ec80..a5d92839f8 100644
--- a/modules/java/src/java/core+MatOfByte.java
+++ b/modules/java/src/java/core+MatOfByte.java
@@ -4,38 +4,34 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfByte extends Mat {
-	// 8UC(x)
-	private static final int _depth = CvType.CV_8U;
-	private final int _channels;
-
-    public MatOfByte(int channels) {
-        super();
-        _channels = channels;
-    }
+    // 8UC(x)
+    private static final int _depth = CvType.CV_8U;
+    private static final int _channels = 1;
 
     public MatOfByte() {
-        this(1);
+        super();
     }
-
-    public MatOfByte(int channels, long addr) {
+    
+    protected MatOfByte(long addr) {
         super(addr);
-        _channels = channels;
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfByte(int channels, Mat m) {
-    	super(m, Range.all());
-        _channels = channels;
+    public static MatOfByte fromNativeAddr(long addr) {
+        return new MatOfByte(addr);
+    }
+
+    public MatOfByte(Mat m) {
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfByte(int channels, byte...a) {
+    public MatOfByte(byte...a) {
         super();
-        _channels = channels;
         fromArray(a);
     }
 
@@ -51,9 +47,11 @@ public class MatOfByte extends Mat {
         alloc(num);
         put(0, 0, a); //TODO: check ret val!
     }
-    
+
     public byte[] toArray() {
-        int num = (int) total();
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
         byte[] a = new byte[num * _channels];
         if(num == 0)
             return a;
@@ -62,20 +60,20 @@ public class MatOfByte extends Mat {
     }
 
     public void fromList(List<Byte> lb) {
-    	if(lb==null || lb.size()==0)
-    		return;
-    	Byte ab[] = lb.toArray(null);
-    	byte a[] = new byte[ab.length];
-    	for(int i=0; i<ab.length; i++)
-    		a[i] = ab[i];
-    	fromArray(a);
+        if(lb==null || lb.size()==0)
+            return;
+        Byte ab[] = lb.toArray(new Byte[0]);
+        byte a[] = new byte[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
     }
-    
+
     public List<Byte> toList() {
-    	byte[] a = toArray();
-    	Byte ab[] = new Byte[a.length];
-    	for(int i=0; i<a.length; i++)
-    		ab[i] = a[i];
-    	return Arrays.asList(ab); 
+        byte[] a = toArray();
+        Byte ab[] = new Byte[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
     }
 }
diff --git a/modules/java/src/java/core+MatOfDMatch.java b/modules/java/src/java/core+MatOfDMatch.java
index 9a4ace305a..d4b1b052e9 100644
--- a/modules/java/src/java/core+MatOfDMatch.java
+++ b/modules/java/src/java/core+MatOfDMatch.java
@@ -6,23 +6,27 @@ import java.util.List;
 import org.opencv.features2d.DMatch;
 
 public class MatOfDMatch extends Mat {
-	// 32FC4
-	private static final int _depth = CvType.CV_32F;
-	private static final int _channels = 4;
+    // 32FC4
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 4;
 
     public MatOfDMatch() {
         super();
     }
 
-    public MatOfDMatch(long addr) {
+    protected MatOfDMatch(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfDMatch fromNativeAddr(long addr) {
+        return new MatOfDMatch(addr);
+    }
+
     public MatOfDMatch(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -32,7 +36,7 @@ public class MatOfDMatch extends Mat {
         super();
         fromArray(ap);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -68,12 +72,12 @@ public class MatOfDMatch extends Mat {
     }
 
     public void fromList(List<DMatch> ldm) {
-    	DMatch adm[] = ldm.toArray(null);
-    	fromArray(adm);
+        DMatch adm[] = ldm.toArray(new DMatch[0]);
+        fromArray(adm);
     }
-    
+
     public List<DMatch> toList() {
-    	DMatch[] adm = toArray();
-    	return Arrays.asList(adm); 
+        DMatch[] adm = toArray();
+        return Arrays.asList(adm);
     }
 }
diff --git a/modules/java/src/java/core+MatOfDouble.java b/modules/java/src/java/core+MatOfDouble.java
index 165b9dbdef..2ea210bfa5 100644
--- a/modules/java/src/java/core+MatOfDouble.java
+++ b/modules/java/src/java/core+MatOfDouble.java
@@ -4,38 +4,34 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfDouble extends Mat {
-	// 64FC(x)
-	private static final int _depth = CvType.CV_64F;
-	private final int _channels;
-
-    public MatOfDouble(int channels) {
-        super();
-        _channels = channels;
-    }
+    // 64FC(x)
+    private static final int _depth = CvType.CV_64F;
+    private static final int _channels = 1;
 
     public MatOfDouble() {
-        this(1);
+        super();
     }
 
-    public MatOfDouble(int channels, long addr) {
+    protected MatOfDouble(long addr) {
         super(addr);
-        _channels = channels;
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfDouble(int channels, Mat m) {
-    	super(m, Range.all());
-        _channels = channels;
+    public static MatOfDouble fromNativeAddr(long addr) {
+		return new MatOfDouble(addr);
+	}
+
+    public MatOfDouble(Mat m) {
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfDouble(int channels, double...a) {
+    public MatOfDouble(double...a) {
         super();
-        _channels = channels;
         fromArray(a);
     }
 
@@ -51,9 +47,11 @@ public class MatOfDouble extends Mat {
         alloc(num);
         put(0, 0, a); //TODO: check ret val!
     }
-    
+
     public double[] toArray() {
-        int num = (int) total();
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
         double[] a = new double[num * _channels];
         if(num == 0)
             return a;
@@ -62,20 +60,20 @@ public class MatOfDouble extends Mat {
     }
 
     public void fromList(List<Double> lb) {
-    	if(lb==null || lb.size()==0)
-    		return;
-    	Double ab[] = lb.toArray(null);
-    	double a[] = new double[ab.length];
-    	for(int i=0; i<ab.length; i++)
-    		a[i] = ab[i];
-    	fromArray(a);
+        if(lb==null || lb.size()==0)
+            return;
+        Double ab[] = lb.toArray(new Double[0]);
+        double a[] = new double[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
     }
-    
+
     public List<Double> toList() {
-    	double[] a = toArray();
-    	Double ab[] = new Double[a.length];
-    	for(int i=0; i<a.length; i++)
-    		ab[i] = a[i];
-    	return Arrays.asList(ab); 
+        double[] a = toArray();
+        Double ab[] = new Double[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
     }
 }
diff --git a/modules/java/src/java/core+MatOfFloat.java b/modules/java/src/java/core+MatOfFloat.java
index 809a0de2fa..ca3a8377d9 100644
--- a/modules/java/src/java/core+MatOfFloat.java
+++ b/modules/java/src/java/core+MatOfFloat.java
@@ -4,38 +4,34 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfFloat extends Mat {
-	// 32FC(x)
-	private static final int _depth = CvType.CV_32F;
-	private final int _channels;
-
-    public MatOfFloat(int channels) {
-        super();
-        _channels = channels;
-    }
+    // 32FC1
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 1;
 
     public MatOfFloat() {
-        this(1);
+        super();
     }
 
-    public MatOfFloat(int channels, long addr) {
+    protected MatOfFloat(long addr) {
         super(addr);
-        _channels = channels;
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
+    
+    public static MatOfFloat fromNativeAddr(long addr) {
+		return new MatOfFloat(addr);
+	}
 
-    public MatOfFloat(int channels, Mat m) {
-    	super(m, Range.all());
-        _channels = channels;
+    public MatOfFloat(Mat m) {
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfFloat(int channels, float...a) {
+    public MatOfFloat(float...a) {
         super();
-        _channels = channels;
         fromArray(a);
     }
 
@@ -51,9 +47,11 @@ public class MatOfFloat extends Mat {
         alloc(num);
         put(0, 0, a); //TODO: check ret val!
     }
-    
+
     public float[] toArray() {
-        int num = (int) total();
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
         float[] a = new float[num * _channels];
         if(num == 0)
             return a;
@@ -62,20 +60,20 @@ public class MatOfFloat extends Mat {
     }
 
     public void fromList(List<Float> lb) {
-    	if(lb==null || lb.size()==0)
-    		return;
-    	Float ab[] = lb.toArray(null);
-    	float a[] = new float[ab.length];
-    	for(int i=0; i<ab.length; i++)
-    		a[i] = ab[i];
-    	fromArray(a);
+        if(lb==null || lb.size()==0)
+            return;
+        Float ab[] = lb.toArray(new Float[0]);
+        float a[] = new float[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
     }
-    
+
     public List<Float> toList() {
-    	float[] a = toArray();
-    	Float ab[] = new Float[a.length];
-    	for(int i=0; i<a.length; i++)
-    		ab[i] = a[i];
-    	return Arrays.asList(ab); 
+        float[] a = toArray();
+        Float ab[] = new Float[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
     }
 }
diff --git a/modules/java/src/java/core+MatOfFloat4.java b/modules/java/src/java/core+MatOfFloat4.java
new file mode 100644
index 0000000000..14b37ff1ed
--- /dev/null
+++ b/modules/java/src/java/core+MatOfFloat4.java
@@ -0,0 +1,79 @@
+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MatOfFloat4 extends Mat {
+    // 32FC4
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 4;
+
+    public MatOfFloat4() {
+        super();
+    }
+
+    protected MatOfFloat4(long addr) {
+        super(addr);
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+    
+    public static MatOfFloat4 fromNativeAddr(long addr) {
+		return new MatOfFloat4(addr);
+	}
+
+    public MatOfFloat4(Mat m) {
+        super(m, Range.all());
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfFloat4(float...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(float...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public float[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        float[] a = new float[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Float> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Float ab[] = lb.toArray(new Float[0]);
+        float a[] = new float[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Float> toList() {
+        float[] a = toArray();
+        Float ab[] = new Float[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}
diff --git a/modules/java/src/java/core+MatOfFloat6.java b/modules/java/src/java/core+MatOfFloat6.java
new file mode 100644
index 0000000000..de9ce902af
--- /dev/null
+++ b/modules/java/src/java/core+MatOfFloat6.java
@@ -0,0 +1,79 @@
+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class MatOfFloat6 extends Mat {
+    // 32FC6
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 6;
+
+    public MatOfFloat6() {
+        super();
+    }
+
+    protected MatOfFloat6(long addr) {
+        super(addr);
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+    
+    public static MatOfFloat6 fromNativeAddr(long addr) {
+		return new MatOfFloat6(addr);
+	}
+
+    public MatOfFloat6(Mat m) {
+        super(m, Range.all());
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfFloat6(float...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(float...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public float[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        float[] a = new float[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Float> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Float ab[] = lb.toArray(new Float[0]);
+        float a[] = new float[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Float> toList() {
+        float[] a = toArray();
+        Float ab[] = new Float[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}
diff --git a/modules/java/src/java/core+MatOfInt.java b/modules/java/src/java/core+MatOfInt.java
index d019438b88..36a86b3cf1 100644
--- a/modules/java/src/java/core+MatOfInt.java
+++ b/modules/java/src/java/core+MatOfInt.java
@@ -5,38 +5,34 @@ import java.util.List;
 
 
 public class MatOfInt extends Mat {
-	// 32SC(x)
-	private static final int _depth = CvType.CV_32S;
-	private final int _channels;
-
-    public MatOfInt(int channels) {
-        super();
-        _channels = channels;
-    }
+    // 32SC1
+    private static final int _depth = CvType.CV_32S;
+    private static final int _channels = 1;
 
     public MatOfInt() {
-        this(1);
+        super();
     }
 
-    public MatOfInt(int channels, long addr) {
+    protected MatOfInt(long addr) {
         super(addr);
-        _channels = channels;
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfInt(int channels, Mat m) {
-    	super(m, Range.all());
-        _channels = channels;
+    public static MatOfInt fromNativeAddr(long addr) {
+        return new MatOfInt(addr);
+    }
+
+    public MatOfInt(Mat m) {
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
-    public MatOfInt(int channels, int...a) {
+    public MatOfInt(int...a) {
         super();
-        _channels = channels;
         fromArray(a);
     }
 
@@ -52,9 +48,11 @@ public class MatOfInt extends Mat {
         alloc(num);
         put(0, 0, a); //TODO: check ret val!
     }
-    
+
     public int[] toArray() {
-        int num = (int) total();
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
         int[] a = new int[num * _channels];
         if(num == 0)
             return a;
@@ -63,20 +61,20 @@ public class MatOfInt extends Mat {
     }
 
     public void fromList(List<Integer> lb) {
-    	if(lb==null || lb.size()==0)
-    		return;
-    	Integer ab[] = lb.toArray(null);
-    	int a[] = new int[ab.length];
-    	for(int i=0; i<ab.length; i++)
-    		a[i] = ab[i];
-    	fromArray(a);
+        if(lb==null || lb.size()==0)
+            return;
+        Integer ab[] = lb.toArray(new Integer[0]);
+        int a[] = new int[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
     }
-    
+
     public List<Integer> toList() {
-    	int[] a = toArray();
-    	Integer ab[] = new Integer[a.length];
-    	for(int i=0; i<a.length; i++)
-    		ab[i] = a[i];
-    	return Arrays.asList(ab); 
+        int[] a = toArray();
+        Integer ab[] = new Integer[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
     }
 }
diff --git a/modules/java/src/java/core+MatOfInt4.java b/modules/java/src/java/core+MatOfInt4.java
new file mode 100644
index 0000000000..64c1b9ba3c
--- /dev/null
+++ b/modules/java/src/java/core+MatOfInt4.java
@@ -0,0 +1,80 @@
+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+
+public class MatOfInt4 extends Mat {
+    // 32SC4
+    private static final int _depth = CvType.CV_32S;
+    private static final int _channels = 4;
+
+    public MatOfInt4() {
+        super();
+    }
+
+    protected MatOfInt4(long addr) {
+        super(addr);
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfInt4 fromNativeAddr(long addr) {
+        return new MatOfInt4(addr);
+    }
+
+    public MatOfInt4(Mat m) {
+        super(m, Range.all());
+        if(checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incomatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfInt4(int...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(int...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length / _channels;
+        alloc(num);
+        put(0, 0, a); //TODO: check ret val!
+    }
+
+    public int[] toArray() {
+        int num = checkVector(_channels, _depth);
+        if(num < 0)
+        	throw new RuntimeException("Native Mat has unexpected type or size: " + toString());
+        int[] a = new int[num * _channels];
+        if(num == 0)
+            return a;
+        get(0, 0, a); //TODO: check ret val!
+        return a;
+    }
+
+    public void fromList(List<Integer> lb) {
+        if(lb==null || lb.size()==0)
+            return;
+        Integer ab[] = lb.toArray(new Integer[0]);
+        int a[] = new int[ab.length];
+        for(int i=0; i<ab.length; i++)
+            a[i] = ab[i];
+        fromArray(a);
+    }
+
+    public List<Integer> toList() {
+        int[] a = toArray();
+        Integer ab[] = new Integer[a.length];
+        for(int i=0; i<a.length; i++)
+            ab[i] = a[i];
+        return Arrays.asList(ab);
+    }
+}
diff --git a/modules/java/src/java/core+MatOfKeyPoint.java b/modules/java/src/java/core+MatOfKeyPoint.java
index e310be2df8..3be7c3e397 100644
--- a/modules/java/src/java/core+MatOfKeyPoint.java
+++ b/modules/java/src/java/core+MatOfKeyPoint.java
@@ -6,23 +6,27 @@ import java.util.List;
 import org.opencv.features2d.KeyPoint;
 
 public class MatOfKeyPoint extends Mat {
-	// 32FC7
-	private static final int _depth = CvType.CV_32F;
-	private static final int _channels = 7;
+    // 32FC7
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 7;
 
     public MatOfKeyPoint() {
         super();
     }
 
-    public MatOfKeyPoint(long addr) {
+    protected MatOfKeyPoint(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfKeyPoint fromNativeAddr(long addr) {
+		return new MatOfKeyPoint(addr);
+	}
+
     public MatOfKeyPoint(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -32,7 +36,7 @@ public class MatOfKeyPoint extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -71,12 +75,12 @@ public class MatOfKeyPoint extends Mat {
     }
 
     public void fromList(List<KeyPoint> lkp) {
-    	KeyPoint akp[] = lkp.toArray(null);
-    	fromArray(akp);
+        KeyPoint akp[] = lkp.toArray(new KeyPoint[0]);
+        fromArray(akp);
     }
-    
+
     public List<KeyPoint> toList() {
-    	KeyPoint[] akp = toArray();
-    	return Arrays.asList(akp); 
+        KeyPoint[] akp = toArray();
+        return Arrays.asList(akp);
     }
 }
diff --git a/modules/java/src/java/core+MatOfPoint.java b/modules/java/src/java/core+MatOfPoint.java
index b0dc449987..81475e96da 100644
--- a/modules/java/src/java/core+MatOfPoint.java
+++ b/modules/java/src/java/core+MatOfPoint.java
@@ -4,23 +4,27 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfPoint extends Mat {
-	// 32SC2
-	private static final int _depth = CvType.CV_32S;
-	private static final int _channels = 2;
+    // 32SC2
+    private static final int _depth = CvType.CV_32S;
+    private static final int _channels = 2;
 
     public MatOfPoint() {
         super();
     }
 
-    public MatOfPoint(long addr) {
+    protected MatOfPoint(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfPoint fromNativeAddr(long addr) {
+		return new MatOfPoint(addr);
+	}
+
     public MatOfPoint(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -30,7 +34,7 @@ public class MatOfPoint extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -49,7 +53,7 @@ public class MatOfPoint extends Mat {
         }
         put(0, 0, buff); //TODO: check ret val!
     }
-    
+
     public Point[] toArray() {
         int num = (int) total();
         Point[] ap = new Point[num];
@@ -63,12 +67,12 @@ public class MatOfPoint extends Mat {
     }
 
     public void fromList(List<Point> lp) {
-    	Point ap[] = lp.toArray(null);
-    	fromArray(ap);
+        Point ap[] = lp.toArray(new Point[0]);
+        fromArray(ap);
     }
-    
+
     public List<Point> toList() {
-    	Point[] ap = toArray();
-    	return Arrays.asList(ap); 
+        Point[] ap = toArray();
+        return Arrays.asList(ap);
     }
 }
diff --git a/modules/java/src/java/core+MatOfPoint2f.java b/modules/java/src/java/core+MatOfPoint2f.java
index d8667695e2..dd1257f5c9 100644
--- a/modules/java/src/java/core+MatOfPoint2f.java
+++ b/modules/java/src/java/core+MatOfPoint2f.java
@@ -4,23 +4,27 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfPoint2f extends Mat {
-	// 32FC2
-	private static final int _depth = CvType.CV_32F;
-	private static final int _channels = 2;
+    // 32FC2
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 2;
 
     public MatOfPoint2f() {
         super();
     }
 
-    public MatOfPoint2f(long addr) {
+    protected MatOfPoint2f(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfPoint2f fromNativeAddr(long addr) {
+		return new MatOfPoint2f(addr);
+	}
+
     public MatOfPoint2f(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -30,7 +34,7 @@ public class MatOfPoint2f extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -49,7 +53,7 @@ public class MatOfPoint2f extends Mat {
         }
         put(0, 0, buff); //TODO: check ret val!
     }
-    
+
     public Point[] toArray() {
         int num = (int) total();
         Point[] ap = new Point[num];
@@ -63,12 +67,12 @@ public class MatOfPoint2f extends Mat {
     }
 
     public void fromList(List<Point> lp) {
-    	Point ap[] = lp.toArray(null);
-    	fromArray(ap);
+        Point ap[] = lp.toArray(new Point[0]);
+        fromArray(ap);
     }
-    
+
     public List<Point> toList() {
-    	Point[] ap = toArray();
-    	return Arrays.asList(ap); 
+        Point[] ap = toArray();
+        return Arrays.asList(ap);
     }
 }
diff --git a/modules/java/src/java/core+MatOfPoint3.java b/modules/java/src/java/core+MatOfPoint3.java
index 71a60829d8..25320759ca 100644
--- a/modules/java/src/java/core+MatOfPoint3.java
+++ b/modules/java/src/java/core+MatOfPoint3.java
@@ -4,23 +4,27 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfPoint3 extends Mat {
-	// 32SC3
-	private static final int _depth = CvType.CV_32S;
-	private static final int _channels = 3;
+    // 32SC3
+    private static final int _depth = CvType.CV_32S;
+    private static final int _channels = 3;
 
     public MatOfPoint3() {
         super();
     }
 
-    public MatOfPoint3(long addr) {
+    protected MatOfPoint3(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfPoint3 fromNativeAddr(long addr) {
+		return new MatOfPoint3(addr);
+	}
+
     public MatOfPoint3(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -30,7 +34,7 @@ public class MatOfPoint3 extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -50,7 +54,7 @@ public class MatOfPoint3 extends Mat {
         }
         put(0, 0, buff); //TODO: check ret val!
     }
-    
+
     public Point3[] toArray() {
         int num = (int) total();
         Point3[] ap = new Point3[num];
@@ -64,12 +68,12 @@ public class MatOfPoint3 extends Mat {
     }
 
     public void fromList(List<Point3> lp) {
-    	Point3 ap[] = lp.toArray(null);
-    	fromArray(ap);
+        Point3 ap[] = lp.toArray(new Point3[0]);
+        fromArray(ap);
     }
-    
+
     public List<Point3> toList() {
-    	Point3[] ap = toArray();
-    	return Arrays.asList(ap); 
+        Point3[] ap = toArray();
+        return Arrays.asList(ap);
     }
 }
diff --git a/modules/java/src/java/core+MatOfPoint3f.java b/modules/java/src/java/core+MatOfPoint3f.java
index 76e180bc3f..f765f23605 100644
--- a/modules/java/src/java/core+MatOfPoint3f.java
+++ b/modules/java/src/java/core+MatOfPoint3f.java
@@ -4,23 +4,27 @@ import java.util.Arrays;
 import java.util.List;
 
 public class MatOfPoint3f extends Mat {
-	// 32FC3
-	private static final int _depth = CvType.CV_32F;
-	private static final int _channels = 3;
+    // 32FC3
+    private static final int _depth = CvType.CV_32F;
+    private static final int _channels = 3;
 
     public MatOfPoint3f() {
         super();
     }
 
-    public MatOfPoint3f(long addr) {
+    protected MatOfPoint3f(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfPoint3f fromNativeAddr(long addr) {
+		return new MatOfPoint3f(addr);
+	}
+
     public MatOfPoint3f(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -30,7 +34,7 @@ public class MatOfPoint3f extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -50,7 +54,7 @@ public class MatOfPoint3f extends Mat {
         }
         put(0, 0, buff); //TODO: check ret val!
     }
-    
+
     public Point3[] toArray() {
         int num = (int) total();
         Point3[] ap = new Point3[num];
@@ -64,12 +68,12 @@ public class MatOfPoint3f extends Mat {
     }
 
     public void fromList(List<Point3> lp) {
-    	Point3 ap[] = lp.toArray(null);
-    	fromArray(ap);
+        Point3 ap[] = lp.toArray(new Point3[0]);
+        fromArray(ap);
     }
-    
+
     public List<Point3> toList() {
-    	Point3[] ap = toArray();
-    	return Arrays.asList(ap); 
+        Point3[] ap = toArray();
+        return Arrays.asList(ap);
     }
 }
diff --git a/modules/java/src/java/core+MatOfRect.java b/modules/java/src/java/core+MatOfRect.java
index 2688b56235..4798df738b 100644
--- a/modules/java/src/java/core+MatOfRect.java
+++ b/modules/java/src/java/core+MatOfRect.java
@@ -5,23 +5,27 @@ import java.util.List;
 
 
 public class MatOfRect extends Mat {
-	// 32SC4
-	private static final int _depth = CvType.CV_32S;
-	private static final int _channels = 4;
+    // 32SC4
+    private static final int _depth = CvType.CV_32S;
+    private static final int _channels = 4;
 
     public MatOfRect() {
         super();
     }
 
-    public MatOfRect(long addr) {
+    protected MatOfRect(long addr) {
         super(addr);
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
     }
 
+    public static MatOfRect fromNativeAddr(long addr) {
+		return new MatOfRect(addr);
+	}
+
     public MatOfRect(Mat m) {
-    	super(m, Range.all());
+        super(m, Range.all());
         if(checkVector(_channels, _depth) < 0 )
             throw new IllegalArgumentException("Incomatible Mat");
         //FIXME: do we need release() here?
@@ -31,7 +35,7 @@ public class MatOfRect extends Mat {
         super();
         fromArray(a);
     }
-    
+
     public void alloc(int elemNumber) {
         if(elemNumber>0)
             super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
@@ -44,7 +48,7 @@ public class MatOfRect extends Mat {
         alloc(num);
         int buff[] = new int[num * _channels];
         for(int i=0; i<num; i++) {
-        	Rect r = a[i];
+            Rect r = a[i];
             buff[_channels*i+0] = (int) r.x;
             buff[_channels*i+1] = (int) r.y;
             buff[_channels*i+2] = (int) r.width;
@@ -52,7 +56,7 @@ public class MatOfRect extends Mat {
         }
         put(0, 0, buff); //TODO: check ret val!
     }
-    
+
 
     public Rect[] toArray() {
         int num = (int) total();
@@ -66,12 +70,12 @@ public class MatOfRect extends Mat {
         return a;
     }
     public void fromList(List<Rect> lr) {
-    	Rect ap[] = lr.toArray(null);
-    	fromArray(ap);
+        Rect ap[] = lr.toArray(new Rect[0]);
+        fromArray(ap);
     }
-    
+
     public List<Rect> toList() {
-    	Rect[] ar = toArray();
-    	return Arrays.asList(ar); 
+        Rect[] ar = toArray();
+        return Arrays.asList(ar);
     }
 }
diff --git a/modules/java/src/java/utils+Converters.java b/modules/java/src/java/utils+Converters.java
index 20c8a711ac..006edff09a 100644
--- a/modules/java/src/java/utils+Converters.java
+++ b/modules/java/src/java/utils+Converters.java
@@ -10,6 +10,7 @@ import org.opencv.core.MatOfDMatch;
 import org.opencv.core.MatOfKeyPoint;
 import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.MatOfPoint3f;
 import org.opencv.core.Point;
 import org.opencv.core.Point3;
 import org.opencv.core.Rect;
@@ -519,6 +520,50 @@ public class Converters {
         }
     }
 
+    // vector_vector_Point2f
+    public static Mat vector_vector_Point2f_to_Mat(List<MatOfPoint2f> pts, List<Mat> mats) {
+        Mat res;
+        int lCount = (pts != null) ? pts.size() : 0;
+        if (lCount > 0) {
+            for (MatOfPoint2f vpt : pts)
+                mats.add(vpt);
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
+    // vector_vector_Point3f
+    public static void Mat_to_vector_vector_Point3f(Mat m, List<MatOfPoint3f> 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);
+        for (Mat mi : mats) {
+            MatOfPoint3f pt = new MatOfPoint3f(mi);
+            pts.add(pt);
+        }
+    }
+
+    // vector_vector_Point3f
+    public static Mat vector_vector_Point3f_to_Mat(List<MatOfPoint3f> pts, List<Mat> mats) {
+        Mat res;
+        int lCount = (pts != null) ? pts.size() : 0;
+        if (lCount > 0) {
+            for (MatOfPoint3f vpt : pts)
+                mats.add(vpt);
+            res = vector_Mat_to_Mat(mats);
+        } else {
+            res = new Mat();
+        }
+        return res;
+    }
+
     // vector_vector_KeyPoint
     public static Mat vector_vector_KeyPoint_to_Mat(List<MatOfKeyPoint> kps, List<Mat> mats) {
         Mat res;