public class OpenCVTestCase extends TestCase {
- protected static int matSize = 10;
- protected static double EPS = 0.001;
- protected static double weakEPS = 0.5;
+ protected static final int matSize = 10;
+ protected static final double EPS = 0.001;
+ protected static final double weakEPS = 0.5;
- protected static Mat dst;
- protected static Mat truth;
+ protected Mat dst;
+ protected Mat truth;
- protected static Scalar colorBlack;
- protected static Scalar colorWhite;
+ protected Scalar colorBlack;
+ protected Scalar colorWhite;
// Naming notation: <channels info>_[depth]_[dimensions]_value
// examples: gray0 - single channel 8U 2d Mat filled with 0
// - rename matrices
// - create methods gray0() and create src1 explicitly
// - create some masks
- // - use truth member everywhere
-
- protected static Mat gray0;
- protected static Mat gray1;
- protected static Mat gray2;
- protected static Mat gray3;
- protected static Mat gray9;
- protected static Mat gray127;
- protected static Mat gray128;
- protected static Mat gray255;
- protected static Mat grayRnd;
-
- protected static Mat gray_16u_256;
- protected static Mat gray_16s_1024;
-
- protected static Mat gray0_32f;
- protected static Mat gray1_32f;
- protected static Mat gray3_32f;
- protected static Mat gray9_32f;
- protected static Mat gray255_32f;
- protected static Mat grayE_32f;
- protected static Mat grayRnd_32f;
-
- protected static Mat gray0_32f_1d;
-
- protected static Mat gray0_64f;
- protected static Mat gray0_64f_1d;
-
- protected static Mat rgba0;
- protected static Mat rgba128;
-
- protected static Mat rgbLena;
- protected static Mat grayChess;
-
- protected static Mat v1;
- protected static Mat v2;
+ // - 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 {
import java.io.IOException;
/**
- * This only class is Android specific. The original idea about test order
- * randomization is from marek.defecinski blog.
+ * This only class is Android specific.
*
* @see <a href="http://opencv.itseez.com">OpenCV</a>
*/
}
static public void Log(Mat m) {
- Log.e(TAG, m + "\n" + m.dump());
+ Log.e(TAG, m + "\n " + m.dump());
}
@Override
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
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.Size;
import org.opencv.core.TermCriteria;
import org.opencv.test.OpenCVTestCase;
-import org.opencv.test.OpenCVTestRunner;
import org.opencv.utils.Converters;
public class CoreTest extends OpenCVTestCase {
Core.checkRange(outOfRange, false);
fail("Core.checkRange should throw the CvException");
} catch (CvException e) {
- //expected
+ // expected
}
}
assertFalse(Core.checkRange(outOfRange, true, null));
assertFalse(Core.checkRange(outOfRange, true, pt));
-
- assertPointEquals(new Point(2,0), pt, EPS);
+
+ assertPointEquals(new Point(2, 0), pt, EPS);
}
public void testCheckRangeMatBooleanPointDouble() {
Scalar color = new Scalar(128);
assertTrue(0 == Core.countNonZero(gray0));
- Core.circle(gray0, center, radius, color, -1 /* filled circle */);
+ Core.circle(gray0, center, radius, color, Core.FILLED);
assertTrue(0 != Core.countNonZero(gray0));
}
Scalar color = new Scalar(128);
assertTrue(0 == Core.countNonZero(gray0));
- Core.circle(gray0, center, radius, color, 2, 4/* 4-connected line */);
+ Core.circle(gray0, center, radius, color, 2, Core.LINE_4);
assertTrue(0 != Core.countNonZero(gray0));
}
double angle = 30, startAngle = 60, endAngle = 90;
assertTrue(0 == Core.countNonZero(gray0));
- Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, -1);//TODO: CV_FILLED ??
+ Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED);
assertTrue(0 != Core.countNonZero(gray0));
}
Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
Size axes = new Size(2, 2);
double angle = 30, startAngle = 0, endAngle = 30;
- int lineType = 4;//FIXME: use constant
assertTrue(0 == Core.countNonZero(gray0));
- Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, -1, lineType);
+ Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED, Core.LINE_4);
assertTrue(0 != Core.countNonZero(gray0));
}
Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
Size axes = new Size(2, 2);
double angle = 30, startAngle = 0, endAngle = 30;
- int lineType = 4;//FIXME: use constant
int shift = 1;
- assertTrue(0 == Core.countNonZero(gray0));
- Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, -1, lineType, shift);
+
+ Core.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED, Core.LINE_4, shift);
assertTrue(0 != Core.countNonZero(gray0));
}
public void testEllipseMatRotatedRectScalar() {
+ int matSize = 10;
+ gray0 = Mat.zeros(matSize, matSize, CvType.CV_8U);
Point center = new Point(matSize / 2, matSize / 2);
Size size = new Size(matSize / 4, matSize / 2);
- double angle = 40;
- RotatedRect box = new RotatedRect(center, size, angle);
- Core.ellipse(gray0, box, colorWhite);
- // TODO: How do we get access to ellipse's center
- // assertTrue(box.center.equals(ellipse.center));
- fail("Not yet implemented");
+ 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(gray0.size(), CvType.CV_8U) {
+ {
+ put(0, 0, truth);
+ }
+ }, gray0);
}
public void testEllipseMatRotatedRectScalarInt() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
assertEquals(75.96, res2, delta);
}
- public void testFillConvexPolyMatMatScalar() {
- List<Point> lp = new ArrayList<Point>(4);
- lp.add(new Point(1, 1));
- lp.add(new Point(5, 0));
- lp.add(new Point(6, 8));
- lp.add(new Point(0, 9));
- Mat points = Converters.vector_Point_to_Mat(lp);
- assertTrue(0 == Core.countNonZero(gray0));
+ 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, points, new Scalar(150));
+ Core.fillConvexPoly(gray0, polyline, new Scalar(150));
assertTrue(0 < Core.countNonZero(gray0));
-
- Core.fillConvexPoly(gray0, points, new Scalar(0));
- assertTrue(0 == Core.countNonZero(gray0));
+ assertTrue(gray0.total() > Core.countNonZero(gray0));
}
- public void testFillConvexPolyMatMatScalarInt() {
- List<Point> lp = new ArrayList<Point>(4);
- lp.add(new Point(1, 1));
- lp.add(new Point(5, 0));
- lp.add(new Point(6, 8));
- lp.add(new Point(0, 9));
- Mat points = Converters.vector_Point_to_Mat(lp);
- assertTrue(0 == 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, points, new Scalar(150), 4);
- assertTrue(0 < Core.countNonZero(gray0));
+ Core.fillConvexPoly(gray0, polyline, new Scalar(150), Core.LINE_8);
+ Core.fillConvexPoly(gray0, polyline, new Scalar(0), Core.LINE_4);
- Core.fillConvexPoly(gray0, points, new Scalar(0), 4);
- assertTrue(0 == Core.countNonZero(gray0));
+ assertTrue(0 < Core.countNonZero(gray0));
+ assertTrue(gray0.total() > Core.countNonZero(gray0));
}
- public void testFillConvexPolyMatMatScalarIntInt() {
- List<Point> lp = new ArrayList<Point>();
- lp.add(new Point(1, 1));
- lp.add(new Point(5, 1));
- lp.add(new Point(5, 8));
- lp.add(new Point(1, 8));
- Mat points = Converters.vector_Point_to_Mat(lp);
+ public void testFillConvexPolyMatListOfPointScalarIntInt() {
+ List<Point> polyline1 = Arrays.asList(new Point(1, 1), new Point(5, 1), new Point(5, 8), new Point(1, 8));
+ List<Point> polyline2 = Arrays.asList(new Point(2, 2), new Point(10, 2), new Point(10, 16), new Point(2, 16));
+ /* TODO: this test fails because of a bug!
+ * find source of rounding error - java or OpenCV */
- List<Point> lp2 = new ArrayList<Point>();
- lp2.add(new Point(0, 0));
- lp2.add(new Point(10, 2));
- lp2.add(new Point(10, 16));
- lp2.add(new Point(2, 16));
- Mat points2 = Converters.vector_Point_to_Mat(lp2);
+ Core.fillConvexPoly(gray0, polyline1, colorWhite, Core.LINE_8, 0);
- assertEquals(0, Core.countNonZero(gray0));
- Core.fillConvexPoly(gray0, points, colorWhite, 4 /* TODO: lineType */, 0);
assertTrue(0 < Core.countNonZero(gray0));
+ assertTrue(gray0.total() > Core.countNonZero(gray0));
+
+ Core.fillConvexPoly(gray0, polyline2, colorBlack, Core.LINE_8, 1);
+ // OpenCVTestRunner.Log(gray0);
- Core.fillConvexPoly(gray0, points2, colorBlack, 4 /* TODO: lineType */, 0);
assertEquals(0, Core.countNonZero(gray0));
}
- public void testFillPolyMatListOfMatScalar() {
- fail("Not yet implemented");
+ public void testFillPolyMatListOfListOfPointScalar() {
+ int matSize = 10;
+ 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 testFillPolyMatListOfMatScalarInt() {
- fail("Not yet implemented");
+ 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 testFillPolyMatListOfMatScalarIntInt() {
- fail("Not yet implemented");
+ 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 testFillPolyMatListOfMatScalarIntIntPoint() {
- fail("Not yet implemented");
+ 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() {
}
public void testGetNumberOfCPUs() {
- fail("Not yet implemented");
+ int cpus = Core.getNumberOfCPUs();
+ assertEquals(Runtime.getRuntime().availableProcessors(), cpus);
}
public void testGetOptimalDFTSize() {
}
public void testKmeansMatIntMatTermCriteriaIntInt() {
- fail("Not yet implemented");
- Mat data = new Mat(4, 2, CvType.CV_32FC1);
- data.put(0, 0, 2, 4);
- data.put(1, 0, 3, 9);
- data.put(1, 0, 1, 4);
- data.put(1, 0, 8, 12);
- int K = 3;
- Mat bestLabels = new Mat();
- TermCriteria criteria = new TermCriteria(2/* TODO: CV_TERMCRIT_EPS */, 100, 0);
- double res;
- // TODO: returns 0 for most input combinations
- res = Core.kmeans(data, K, bestLabels, criteria, 0, Core.KMEANS_PP_CENTERS);
- assertEquals(10.0, res);
+ 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() {
- fail("Not yet implemented");
+ 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() {
Point point2 = new Point(nPoints, nPoints);
Scalar color = new Scalar(255);
- assertTrue(0 == Core.countNonZero(gray0));
Core.line(gray0, point1, point2, color);
assertTrue(nPoints == Core.countNonZero(gray0));
}
Point point1 = new Point(0, 0);
Point point2 = new Point(nPoints, nPoints);
- assertTrue(0 == Core.countNonZero(gray0));
Core.line(gray0, point1, point2, colorWhite, 0);
assertTrue(nPoints == Core.countNonZero(gray0));
}
public void testLineMatPointPointScalarIntInt() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
}
public void testPCABackProject() {
- Mat data = new Mat(2, 2, CvType.CV_32F);
- data.put(0, 0, 1, 3);
- data.put(1, 0, 0, 2);
- Mat eigenvectors = new Mat(1, 2, CvType.CV_32F);
- eigenvectors.put(0, 0, 1, 3);
- // Mat mean = new Mat(1, 1, CvType.CV_32F, new Scalar(2.5));
- // Core.PCABackProject(data, new Mat(), eigenvectors, dst);
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
assertMatEqual(y, yCoordinate, EPS);
}
- public void testPolylinesMatListOfMatBooleanScalar() {
+ public void testPolylinesMatListOfListOfPointBooleanScalar() {
Mat img = gray0;
List<Point> pts = new ArrayList<Point>();
pts.add(new Point(1, 1));
pts.add(new Point(7, 1));
pts.add(new Point(7, 6));
pts.add(new Point(1, 6));
- List<Mat> mats = new ArrayList<Mat>();
- mats.add(Converters.vector_Point_to_Mat(pts));
- assertEquals(0, Core.countNonZero(img));
- Core.polylines(img, mats, true, new Scalar(100));
+ List<List<Point>> polyline = new ArrayList<List<Point>>();
+ polyline.add(pts);
+
+ Core.polylines(img, polyline, true, new Scalar(100));
+
assertEquals(22, Core.countNonZero(img));
- Core.polylines(img, mats, false, new Scalar(0));
+ Core.polylines(img, polyline, false, new Scalar(0));
assertEquals(4, Core.countNonZero(img));
}
- public void testPolylinesMatListOfMatBooleanScalarInt() {
+ public void testPolylinesMatListOfListOfPointBooleanScalarInt() {
Mat img = gray0;
List<Point> pts = new ArrayList<Point>();
pts.add(new Point(1, 1));
pts.add(new Point(7, 1));
pts.add(new Point(7, 6));
pts.add(new Point(1, 6));
- List<Mat> mats = new ArrayList<Mat>();
- mats.add(Converters.vector_Point_to_Mat(pts));
- assertEquals(0, Core.countNonZero(img));
- Core.polylines(img, mats, true, new Scalar(100), 2);
+ List<List<Point>> polyline = new ArrayList<List<Point>>();
+ polyline.add(pts);
+
+ Core.polylines(img, polyline, true, new Scalar(100), 2);
+
assertEquals(62, Core.countNonZero(img));
}
- public void testPolylinesMatListOfMatBooleanScalarIntInt() {
+ public void testPolylinesMatListOfListOfPointBooleanScalarIntInt() {
Mat img = gray0;
List<Point> pts = new ArrayList<Point>();
pts.add(new Point(1, 1));
pts.add(new Point(4, 1));
pts.add(new Point(3, 6));
pts.add(new Point(1, 3));
- List<Mat> mats = new ArrayList<Mat>();
- mats.add(Converters.vector_Point_to_Mat(pts));
- assertEquals(0, Core.countNonZero(img));
- Core.polylines(img, mats, true, new Scalar(100), 2, 8);
+ List<List<Point>> polyline = new ArrayList<List<Point>>();
+ polyline.add(pts);
+
+ Core.polylines(img, polyline, true, new Scalar(100), 2, Core.LINE_4);
+
assertEquals(36, Core.countNonZero(img));
}
- public void testPolylinesMatListOfMatBooleanScalarIntIntInt() {
+ public void testPolylinesMatListOfListOfPointBooleanScalarIntIntInt() {
Mat img = gray0;
- List<Point> pts = new ArrayList<Point>();
- List<Point> pts2 = new ArrayList<Point>();
- pts.add(new Point(1, 1));
- pts2.add(new Point(2, 2));
- pts.add(new Point(7, 1));
- pts2.add(new Point(14, 2));
- pts.add(new Point(7, 6));
- pts2.add(new Point(14, 12));
- pts.add(new Point(1, 6));
- pts2.add(new Point(2, 12));
- List<Mat> mats = new ArrayList<Mat>();
- List<Mat> mats2 = new ArrayList<Mat>();
- mats.add(Converters.vector_Point_to_Mat(pts));
- mats2.add(Converters.vector_Point_to_Mat(pts2));
-
- assertTrue(0 == Core.countNonZero(img));
- Core.polylines(img, mats, true, new Scalar(100), 2, 8, 0);
- assertFalse(0 == Core.countNonZero(img));
- Core.polylines(img, mats2, true, new Scalar(0), 2, 8, 1);
- assertTrue(0 == Core.countNonZero(img));
+
+ 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() {
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);
+
+ 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, -1);//TODO:CV_FILLED
+ // 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() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
- fail("Not yet implemented");
+ 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() {
Mat original = new Mat(1, 5, CvType.CV_32F);
original.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();
Mat original = new Mat(1, 5, CvType.CV_32F);
original.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();
Scalar color = new Scalar(128);
assertTrue(0 == Core.countNonZero(gray0));
- Core.rectangle(gray0, center, origin, color, 2, 8);
+ Core.rectangle(gray0, center, origin, color, 2, Core.LINE_8);
assertTrue(0 != Core.countNonZero(gray0));
}
Scalar color = new Scalar(128);
assertTrue(0 == Core.countNonZero(gray0));
- Core.rectangle(gray0, center, origin, color, 2, 4, 2);
+ Core.rectangle(gray0, center, origin, color, 2, Core.LINE_4, 2);
assertTrue(0 != Core.countNonZero(gray0));
}
Mat w = new Mat();
Mat u = new Mat();
Mat vt = new Mat();
- Core.SVDecomp(src, w, u, vt, 1/* TODO: SVD::MODIFY_A */);
+
+ 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);
-
- Mat truthU = new Mat(1, 1, CvType.CV_32FC1, new Scalar(1));
- assertMatEqual(truthU, u, EPS);
-
- Mat truthVT = new Mat(1, 4, CvType.CV_32FC1);
- truthVT.put(0, 0, 0.09245003, 0.36980012, 0.73960024, 0.5547002);
- assertMatEqual(truthVT, vt, EPS);
-
+ assertTrue(u.empty());
+ assertTrue(vt.empty());
}
public void testTrace() {
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);
+ }
+
}
public void testSet() {
fail("Not yet implemented");
}
+
+ 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);
+ }
}
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);
+ }
}
assertEquals(2.0, sz1.width);
assertEquals(4.0, sz1.height);
}
+
+ public void testToString() {
+ String actual = sz1.toString();
+ String expected = "10x10";
+ assertEquals(expected, actual);
+ }
}
public void testMat_to_vector_char() {\r
fail("Not yet implemented");\r
}\r
-\r
+ \r
public void testMat_to_vector_DMatch() {\r
fail("Not yet implemented");\r
}\r
fail("Not yet implemented");\r
}\r
\r
+ public void testVector_vector_Point_to_Mat() {\r
+ fail("Not yet implemented");\r
+ }\r
+\r
}\r
('CV_32S', 4 ),\r
('CV_32F', 5 ), ('CV_64F', 6 ),\r
('CV_USRTYPE1', 7 ),\r
- ) # private\r
+ ), # private\r
+ 'public' :\r
+ (\r
+ ('SVD_MODIFY_A', 1), ('SVD_NO_UV', 2), ('SVD_FULL_UV', 4), \r
+ ('FILLED', -1),\r
+ ('LINE_AA', 16), ('LINE_8', 8), ('LINE_4', 4),\r
+ ) #public\r
}, # Core\r
\r
"Imgproc":\r
\r
# "complex" : { j_type : "?", jn_args : (("", ""),), jn_name : "", jni_var : "", jni_name : "", "suffix" : "?" },\r
\r
- "vector_Point" : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point> %(n)s", "suffix" : "J" },\r
- "vector_Point2f": { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2f> %(n)s", "suffix" : "J" },\r
- "vector_Point2d": { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2d> %(n)s", "suffix" : "J" },\r
- "vector_Point3i": { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3i> %(n)s", "suffix" : "J" },\r
- "vector_Point3f": { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3f> %(n)s", "suffix" : "J" },\r
- "vector_Point3d": { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3d> %(n)s", "suffix" : "J" },\r
- "vector_Mat" : { "j_type" : "List<Mat>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Mat> %(n)s", "suffix" : "J" },\r
- "vector_KeyPoint":{ "j_type" : "List<KeyPoint>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<KeyPoint> %(n)s", "suffix" : "J" },\r
- "vector_DMatch" : { "j_type" : "List<DMatch>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<DMatch> %(n)s", "suffix" : "J" },\r
- "vector_Rect" : { "j_type" : "List<Rect>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Rect> %(n)s", "suffix" : "J" },\r
- "vector_uchar" : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<uchar> %(n)s", "suffix" : "J" },\r
- "vector_char" : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<char> %(n)s", "suffix" : "J" },\r
- "vector_int" : { "j_type" : "List<Integer>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<int> %(n)s", "suffix" : "J" },\r
- "vector_float" : { "j_type" : "List<Float>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<float> %(n)s", "suffix" : "J" },\r
- "vector_double" : { "j_type" : "List<Double>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<double> %(n)s", "suffix" : "J" },\r
-\r
- "vector_vector_KeyPoint":{ "j_type" : "List<List<KeyPoint>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<KeyPoint> > %(n)s" },\r
- "vector_vector_DMatch" : { "j_type" : "List<List<DMatch>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<DMatch> > %(n)s" },\r
- "vector_vector_char" : { "j_type" : "List<List<Byte>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<char> > %(n)s" },\r
+ "vector_Point" : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point> %(n)s", "suffix" : "J" },\r
+ "vector_Point2f" : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2f> %(n)s", "suffix" : "J" },\r
+ "vector_Point2d" : { "j_type" : "List<Point>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point2d> %(n)s", "suffix" : "J" },\r
+ "vector_Point3i" : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3i> %(n)s", "suffix" : "J" },\r
+ "vector_Point3f" : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3f> %(n)s", "suffix" : "J" },\r
+ "vector_Point3d" : { "j_type" : "List<Point3>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Point3d> %(n)s", "suffix" : "J" },\r
+ "vector_Mat" : { "j_type" : "List<Mat>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Mat> %(n)s", "suffix" : "J" },\r
+ "vector_KeyPoint" : { "j_type" : "List<KeyPoint>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<KeyPoint> %(n)s", "suffix" : "J" },\r
+ "vector_DMatch" : { "j_type" : "List<DMatch>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<DMatch> %(n)s", "suffix" : "J" },\r
+ "vector_Rect" : { "j_type" : "List<Rect>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<Rect> %(n)s", "suffix" : "J" },\r
+ "vector_uchar" : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<uchar> %(n)s", "suffix" : "J" },\r
+ "vector_char" : { "j_type" : "List<Byte>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<char> %(n)s", "suffix" : "J" },\r
+ "vector_int" : { "j_type" : "List<Integer>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<int> %(n)s", "suffix" : "J" },\r
+ "vector_float" : { "j_type" : "List<Float>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<float> %(n)s", "suffix" : "J" },\r
+ "vector_double" : { "j_type" : "List<Double>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector<double> %(n)s", "suffix" : "J" },\r
+\r
+ "vector_vector_KeyPoint": { "j_type" : "List<List<KeyPoint>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<KeyPoint> > %(n)s" },\r
+ "vector_vector_DMatch" : { "j_type" : "List<List<DMatch>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<DMatch> > %(n)s" },\r
+ "vector_vector_char" : { "j_type" : "List<List<Byte>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<char> > %(n)s" },\r
+ "vector_vector_Point" : { "j_type" : "List<List<Point>>", "jn_type" : "long", "jni_type" : "jlong", "jni_var" : "vector< vector<Point> > %(n)s" },\r
\r
"Mat" : { "j_type" : "Mat", "jn_type" : "long", "jn_args" : (("__int64", ".nativeObj"),),\r
"jni_var" : "Mat& %(n)s = *((Mat*)%(n)s_nativeObj)",\r
'calcOpticalFlowPyrLK' : { 'prevPts' : 'vector_Point2f', 'nextPts' : 'vector_Point2f',\r
'status' : 'vector_uchar', 'err' : 'vector_float', },\r
'fitEllipse' : { 'points' : 'vector_Point2f', },\r
+ 'fillPoly' : { 'pts' : 'vector_vector_Point', },\r
+ 'polylines' : { 'pts' : 'vector_vector_Point', },\r
+ 'fillConvexPoly' : { 'points' : 'vector_Point', },\r
}, # '', i.e. no class\r
} # func_arg_fix\r
\r
module = "unknown"
try:
for l in inf.readlines():
- if l.lstrip().startswith(self.javadoc_marker):
+ 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)
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(l.replace("\t", " ").rstrip()+"\n")
+ outf.write(org.replace("\t", " ").rstrip()+"\n")
except:
inf.close()
outf.close()
LOGD("highgui::VideoCapture_n_1set()");
#endif // DEBUG
VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
- double addr = me->get(CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING);
- char* result = *((char**)&addr);
- return env->NewStringUTF(result);
+ 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());
}\r
}\r
\r
+void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt)\r
+{\r
+ vector<Mat> vm;\r
+ vm.reserve( mat.rows );\r
+ Mat_to_vector_Mat(mat, vm);\r
+ for(size_t i=0; i<vm.size(); i++)\r
+ {\r
+ vector<Point> vpt;\r
+ Mat_to_vector_Point(vm[i], vpt);\r
+ vv_pt.push_back(vpt);\r
+ }\r
+}\r
+\r
void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp)\r
{\r
vector<Mat> vm;\r
\r
void Mat_to_vector_vector_char(cv::Mat& mat, std::vector< std::vector< char > >& vv_ch);\r
void vector_vector_char_to_Mat(std::vector< std::vector< char > >& vv_ch, cv::Mat& mat);\r
+\r
+void Mat_to_vector_vector_Point(cv::Mat& mat, std::vector< std::vector< cv::Point > >& vv_pt);\r
package org.opencv.core;\r
\r
-public class CvException extends RuntimeException {
+public class CvException extends RuntimeException {\r
\r
- private static final long serialVersionUID = 1L;\r
+ private static final long serialVersionUID = 1L;\r
\r
- public CvException(String msg) {\r
- super(msg);\r
- }\r
+ public CvException(String msg) {\r
+ super(msg);\r
+ }\r
\r
- @Override\r
- public String toString() {\r
- return "CvException [" + super.toString() + "]";\r
- }\r
+ @Override\r
+ public String toString() {\r
+ return "CvException [" + super.toString() + "]";\r
+ }\r
}\r
package org.opencv.core;\r
\r
-\r
public final class CvType {\r
\r
// type depth constants\r
- public static final int CV_8U = 0, CV_8S = 1,\r
- CV_16U = 2, CV_16S = 3,\r
- CV_32S = 4,\r
- CV_32F = 5,\r
- CV_64F = 6,\r
- CV_USRTYPE1=7;\r
+ public static final int\r
+ CV_8U = 0, CV_8S = 1,\r
+ CV_16U = 2, CV_16S = 3,\r
+ CV_32S = 4,\r
+ CV_32F = 5,\r
+ CV_64F = 6,\r
+ CV_USRTYPE1 = 7;\r
\r
// predefined type constants\r
public static final int\r
- CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),\r
- CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),\r
- CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),\r
- CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),\r
- CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),\r
- CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),\r
- CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);\r
+ CV_8UC1 = CV_8UC(1), CV_8UC2 = CV_8UC(2), CV_8UC3 = CV_8UC(3), CV_8UC4 = CV_8UC(4),\r
+ CV_8SC1 = CV_8SC(1), CV_8SC2 = CV_8SC(2), CV_8SC3 = CV_8SC(3), CV_8SC4 = CV_8SC(4),\r
+ CV_16UC1 = CV_16UC(1), CV_16UC2 = CV_16UC(2), CV_16UC3 = CV_16UC(3), CV_16UC4 = CV_16UC(4),\r
+ CV_16SC1 = CV_16SC(1), CV_16SC2 = CV_16SC(2), CV_16SC3 = CV_16SC(3), CV_16SC4 = CV_16SC(4),\r
+ CV_32SC1 = CV_32SC(1), CV_32SC2 = CV_32SC(2), CV_32SC3 = CV_32SC(3), CV_32SC4 = CV_32SC(4),\r
+ CV_32FC1 = CV_32FC(1), CV_32FC2 = CV_32FC(2), CV_32FC3 = CV_32FC(3), CV_32FC4 = CV_32FC(4),\r
+ CV_64FC1 = CV_64FC(1), CV_64FC2 = CV_64FC(2), CV_64FC3 = CV_64FC(3), CV_64FC4 = CV_64FC(4);\r
\r
private static final int CV_CN_MAX = 512, CV_CN_SHIFT = 3, CV_DEPTH_MAX = (1 << CV_CN_SHIFT);\r
\r
public static final int makeType(int depth, int channels) {\r
- if(channels<=0 || channels>=CV_CN_MAX) {\r
+ if (channels <= 0 || channels >= CV_CN_MAX) {\r
throw new java.lang.UnsupportedOperationException(\r
- "Channels count should be 1.." + (CV_CN_MAX-1) );\r
+ "Channels count should be 1.." + (CV_CN_MAX - 1));\r
}\r
- if(depth<0 || depth>=CV_DEPTH_MAX) {\r
+ if (depth < 0 || depth >= CV_DEPTH_MAX) {\r
throw new java.lang.UnsupportedOperationException(\r
- "Data type depth should be 0.." + (CV_DEPTH_MAX-1) );\r
+ "Data type depth should be 0.." + (CV_DEPTH_MAX - 1));\r
}\r
- return (depth & (CV_DEPTH_MAX-1)) + ((channels-1) << CV_CN_SHIFT);\r
+ return (depth & (CV_DEPTH_MAX - 1)) + ((channels - 1) << CV_CN_SHIFT);\r
}\r
\r
+ public static final int CV_8UC(int ch) {\r
+ return makeType(CV_8U, ch);\r
+ }\r
\r
- public static final int CV_8UC(int ch) { return makeType(CV_8U, ch); }\r
-\r
- public static final int CV_8SC(int ch) { return makeType(CV_8S, ch); }\r
+ public static final int CV_8SC(int ch) {\r
+ return makeType(CV_8S, ch);\r
+ }\r
\r
- public static final int CV_16UC(int ch) { return makeType(CV_16U, ch); }\r
+ public static final int CV_16UC(int ch) {\r
+ return makeType(CV_16U, ch);\r
+ }\r
\r
- public static final int CV_16SC(int ch) { return makeType(CV_16S, ch); }\r
+ public static final int CV_16SC(int ch) {\r
+ return makeType(CV_16S, ch);\r
+ }\r
\r
- public static final int CV_32SC(int ch) { return makeType(CV_32S, ch); }\r
+ public static final int CV_32SC(int ch) {\r
+ return makeType(CV_32S, ch);\r
+ }\r
\r
- public static final int CV_32FC(int ch) { return makeType(CV_32F, ch); }\r
+ public static final int CV_32FC(int ch) {\r
+ return makeType(CV_32F, ch);\r
+ }\r
\r
- public static final int CV_64FC(int ch) { return makeType(CV_64F, ch); }\r
+ public static final int CV_64FC(int ch) {\r
+ return makeType(CV_64F, ch);\r
+ }\r
\r
- public static final int channels(int type) { return (type >> CV_CN_SHIFT) + 1; }\r
+ public static final int channels(int type) {\r
+ return (type >> CV_CN_SHIFT) + 1;\r
+ }\r
\r
- public static final int depth(int type) { return type & (CV_DEPTH_MAX-1); }\r
+ public static final int depth(int type) {\r
+ return type & (CV_DEPTH_MAX - 1);\r
+ }\r
\r
- public static final boolean isInteger(int type) { return depth(type) < CV_32F; }\r
+ public static final boolean isInteger(int type) {\r
+ return depth(type) < CV_32F;\r
+ }\r
\r
public static final int ELEM_SIZE(int type) {\r
switch (depth(type)) {\r
- case CV_8U:\r
- case CV_8S:\r
- return channels(type);\r
- case CV_16U:\r
- case CV_16S:\r
- return 2 * channels(type);\r
- case CV_32S:\r
- case CV_32F:\r
- return 4 * channels(type);\r
- case CV_64F:\r
- return 8 * channels(type);\r
- default:\r
- throw new java.lang.UnsupportedOperationException(\r
- "Unsupported CvType value: " + type );\r
+ case CV_8U:\r
+ case CV_8S:\r
+ return channels(type);\r
+ case CV_16U:\r
+ case CV_16S:\r
+ return 2 * channels(type);\r
+ case CV_32S:\r
+ case CV_32F:\r
+ return 4 * channels(type);\r
+ case CV_64F:\r
+ return 8 * channels(type);\r
+ default:\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Unsupported CvType value: " + type);\r
}\r
}\r
\r
public static final String typeToString(int type) {\r
String s;\r
switch (depth(type)) {\r
- case CV_8U:\r
- s = "CV_8U";\r
- break;\r
- case CV_8S:\r
- s = "CV_8S";\r
- break;\r
- case CV_16U:\r
- s = "CV_16U";\r
- break;\r
- case CV_16S:\r
- s = "CV_16S";\r
- break;\r
- case CV_32S:\r
- s = "CV_32S";\r
- break;\r
- case CV_32F:\r
- s = "CV_32F";\r
- break;\r
- case CV_64F:\r
- s = "CV_64F";\r
- break;\r
- default:\r
- s = "CV_USRTYPE1";\r
+ case CV_8U:\r
+ s = "CV_8U";\r
+ break;\r
+ case CV_8S:\r
+ s = "CV_8S";\r
+ break;\r
+ case CV_16U:\r
+ s = "CV_16U";\r
+ break;\r
+ case CV_16S:\r
+ s = "CV_16S";\r
+ break;\r
+ case CV_32S:\r
+ s = "CV_32S";\r
+ break;\r
+ case CV_32F:\r
+ s = "CV_32F";\r
+ break;\r
+ case CV_64F:\r
+ s = "CV_64F";\r
+ break;\r
+ case CV_USRTYPE1:\r
+ s = "CV_USRTYPE1";\r
+ break;\r
+ default:\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Unsupported CvType value: " + type);\r
}\r
\r
int ch = channels(type);\r
- if(ch<=4) return s + "C" + ch;\r
- else return s + "C(" + ch + ")";\r
+ if (ch <= 4)\r
+ return s + "C" + ch;\r
+ else\r
+ return s + "C(" + ch + ")";\r
}\r
\r
}\r
public class Mat {\r
\r
public final long nativeObj;\r
- public Mat(long addr)\r
- {\r
- if(addr == 0) \r
+\r
+ public Mat(long addr)\r
+ {\r
+ if (addr == 0)\r
throw new java.lang.UnsupportedOperationException("Native object address is NULL");\r
nativeObj = addr;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat()\r
+ // C++: Mat::Mat()\r
//\r
\r
- //javadoc: Mat::Mat()\r
- public Mat()\r
+ // javadoc: Mat::Mat()\r
+ public Mat()\r
{\r
- \r
+\r
nativeObj = n_Mat();\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(int rows, int cols, int type)\r
+ // C++: Mat::Mat(int rows, int cols, int type)\r
//\r
\r
- //javadoc: Mat::Mat(rows, cols, type)\r
- public Mat(int rows, int cols, int type)\r
+ // javadoc: Mat::Mat(rows, cols, type)\r
+ public Mat(int rows, int cols, int type)\r
{\r
- \r
+\r
nativeObj = n_Mat(rows, cols, type);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(Size size, int type)\r
+ // C++: Mat::Mat(Size size, int type)\r
//\r
\r
- //javadoc: Mat::Mat(size, type)\r
- public Mat(Size size, int type)\r
+ // javadoc: Mat::Mat(size, type)\r
+ public Mat(Size size, int type)\r
{\r
- \r
+\r
nativeObj = n_Mat(size.width, size.height, type);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(int rows, int cols, int type, Scalar s)\r
+ // C++: Mat::Mat(int rows, int cols, int type, Scalar s)\r
//\r
\r
- //javadoc: Mat::Mat(rows, cols, type, s)\r
- public Mat(int rows, int cols, int type, Scalar s)\r
+ // javadoc: Mat::Mat(rows, cols, type, s)\r
+ public Mat(int rows, int cols, int type, Scalar s)\r
{\r
- \r
+\r
nativeObj = n_Mat(rows, cols, type, s.val[0], s.val[1], s.val[2], s.val[3]);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(Size size, int type, Scalar s)\r
+ // C++: Mat::Mat(Size size, int type, Scalar s)\r
//\r
\r
- //javadoc: Mat::Mat(size, type, s)\r
- public Mat(Size size, int type, Scalar s)\r
+ // javadoc: Mat::Mat(size, type, s)\r
+ public Mat(Size size, int type, Scalar s)\r
{\r
- \r
+\r
nativeObj = n_Mat(size.width, size.height, type, s.val[0], s.val[1], s.val[2], s.val[3]);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())\r
+ // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())\r
//\r
\r
- //javadoc: Mat::Mat(m, rowRange, colRange)\r
- public Mat(Mat m, Range rowRange, Range colRange)\r
+ // javadoc: Mat::Mat(m, rowRange, colRange)\r
+ public Mat(Mat m, Range rowRange, Range colRange)\r
{\r
- \r
+\r
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end);\r
- \r
+\r
return;\r
}\r
\r
- //javadoc: Mat::Mat(m, rowRange)\r
- public Mat(Mat m, Range rowRange)\r
+ // javadoc: Mat::Mat(m, rowRange)\r
+ public Mat(Mat m, Range rowRange)\r
{\r
- \r
+\r
nativeObj = n_Mat(m.nativeObj, rowRange.start, rowRange.end);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat::Mat(Mat m, Rect roi)\r
+ // C++: Mat::Mat(Mat m, Rect roi)\r
//\r
\r
- //javadoc: Mat::Mat(m, roi)\r
- public Mat(Mat m, Rect roi)\r
+ // javadoc: Mat::Mat(m, roi)\r
+ public Mat(Mat m, Rect roi)\r
{\r
- \r
+\r
nativeObj = n_Mat(m.nativeObj, roi.x, roi.y, roi.width, roi.height);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)\r
+ // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)\r
//\r
\r
- //javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)\r
- public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)\r
+ // javadoc: Mat::adjustROI(dtop, dbottom, dleft, dright)\r
+ public Mat adjustROI(int dtop, int dbottom, int dleft, int dright)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_adjustROI(nativeObj, dtop, dbottom, dleft, dright));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: void Mat::assignTo(Mat m, int type = -1)\r
+ // C++: void Mat::assignTo(Mat m, int type = -1)\r
//\r
\r
- //javadoc: Mat::assignTo(m, type)\r
- public void assignTo(Mat m, int type)\r
+ // javadoc: Mat::assignTo(m, type)\r
+ public void assignTo(Mat m, int type)\r
{\r
- \r
+\r
n_assignTo(nativeObj, m.nativeObj, type);\r
- \r
+\r
return;\r
}\r
\r
- //javadoc: Mat::assignTo(m)\r
- public void assignTo(Mat m)\r
+ // javadoc: Mat::assignTo(m)\r
+ public void assignTo(Mat m)\r
{\r
- \r
+\r
n_assignTo(nativeObj, m.nativeObj);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: int Mat::channels()\r
+ // C++: int Mat::channels()\r
//\r
\r
- //javadoc: Mat::channels()\r
- public int channels()\r
+ // javadoc: Mat::channels()\r
+ public int channels()\r
{\r
- \r
+\r
int retVal = n_channels(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool requireContinuous = true)\r
+ // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool\r
+ // requireContinuous = true)\r
//\r
\r
- //javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)\r
- public int checkVector(int elemChannels, int depth, boolean requireContinuous)\r
+ // javadoc: Mat::checkVector(elemChannels, depth, requireContinuous)\r
+ public int checkVector(int elemChannels, int depth, boolean requireContinuous)\r
{\r
- \r
+\r
int retVal = n_checkVector(nativeObj, elemChannels, depth, requireContinuous);\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::checkVector(elemChannels, depth)\r
- public int checkVector(int elemChannels, int depth)\r
+ // javadoc: Mat::checkVector(elemChannels, depth)\r
+ public int checkVector(int elemChannels, int depth)\r
{\r
- \r
+\r
int retVal = n_checkVector(nativeObj, elemChannels, depth);\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::checkVector(elemChannels)\r
- public int checkVector(int elemChannels)\r
+ // javadoc: Mat::checkVector(elemChannels)\r
+ public int checkVector(int elemChannels)\r
{\r
- \r
+\r
int retVal = n_checkVector(nativeObj, elemChannels);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::clone()\r
+ // C++: Mat Mat::clone()\r
//\r
\r
- //javadoc: Mat::clone()\r
- public Mat clone()\r
+ // javadoc: Mat::clone()\r
+ public Mat clone()\r
{\r
- \r
+\r
Mat retVal = new Mat(n_clone(nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::col(int x)\r
+ // C++: Mat Mat::col(int x)\r
//\r
\r
- //javadoc: Mat::col(x)\r
- public Mat col(int x)\r
+ // javadoc: Mat::col(x)\r
+ public Mat col(int x)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_col(nativeObj, x));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::colRange(int startcol, int endcol)\r
+ // C++: Mat Mat::colRange(int startcol, int endcol)\r
//\r
\r
- //javadoc: Mat::colRange(startcol, endcol)\r
- public Mat colRange(int startcol, int endcol)\r
+ // javadoc: Mat::colRange(startcol, endcol)\r
+ public Mat colRange(int startcol, int endcol)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_colRange(nativeObj, startcol, endcol));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::colRange(Range r)\r
+ // C++: Mat Mat::colRange(Range r)\r
//\r
\r
- //javadoc: Mat::colRange(r)\r
- public Mat colRange(Range r)\r
+ // javadoc: Mat::colRange(r)\r
+ public Mat colRange(Range r)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_colRange(nativeObj, r.start, r.end));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: int Mat::cols()\r
+ // C++: int Mat::cols()\r
//\r
\r
- //javadoc: Mat::cols()\r
- public int cols()\r
+ // javadoc: Mat::cols()\r
+ public int cols()\r
{\r
- \r
+\r
int retVal = n_cols(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta = 0)\r
+ // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta\r
+ // = 0)\r
//\r
\r
- //javadoc: Mat::convertTo(m, rtype, alpha, beta)\r
- public void convertTo(Mat m, int rtype, double alpha, double beta)\r
+ // javadoc: Mat::convertTo(m, rtype, alpha, beta)\r
+ public void convertTo(Mat m, int rtype, double alpha, double beta)\r
{\r
- \r
+\r
n_convertTo(nativeObj, m.nativeObj, rtype, alpha, beta);\r
- \r
+\r
return;\r
}\r
\r
- //javadoc: Mat::convertTo(m, rtype, alpha)\r
- public void convertTo(Mat m, int rtype, double alpha)\r
+ // javadoc: Mat::convertTo(m, rtype, alpha)\r
+ public void convertTo(Mat m, int rtype, double alpha)\r
{\r
- \r
+\r
n_convertTo(nativeObj, m.nativeObj, rtype, alpha);\r
- \r
+\r
return;\r
}\r
\r
- //javadoc: Mat::convertTo(m, rtype)\r
- public void convertTo(Mat m, int rtype)\r
+ // javadoc: Mat::convertTo(m, rtype)\r
+ public void convertTo(Mat m, int rtype)\r
{\r
- \r
+\r
n_convertTo(nativeObj, m.nativeObj, rtype);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: void Mat::copyTo(Mat& m)\r
+ // C++: void Mat::copyTo(Mat& m)\r
//\r
\r
- //javadoc: Mat::copyTo(m)\r
- public void copyTo(Mat m)\r
+ // javadoc: Mat::copyTo(m)\r
+ public void copyTo(Mat m)\r
{\r
- \r
+\r
n_copyTo(nativeObj, m.nativeObj);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: void Mat::copyTo(Mat& m, Mat mask)\r
+ // C++: void Mat::copyTo(Mat& m, Mat mask)\r
//\r
\r
- //javadoc: Mat::copyTo(m, mask)\r
- public void copyTo(Mat m, Mat mask)\r
+ // javadoc: Mat::copyTo(m, mask)\r
+ public void copyTo(Mat m, Mat mask)\r
{\r
- \r
+\r
n_copyTo(nativeObj, m.nativeObj, mask.nativeObj);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: void Mat::create(int rows, int cols, int type)\r
+ // C++: void Mat::create(int rows, int cols, int type)\r
//\r
\r
- //javadoc: Mat::create(rows, cols, type)\r
- public void create(int rows, int cols, int type)\r
+ // javadoc: Mat::create(rows, cols, type)\r
+ public void create(int rows, int cols, int type)\r
{\r
- \r
+\r
n_create(nativeObj, rows, cols, type);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: void Mat::create(Size size, int type)\r
+ // C++: void Mat::create(Size size, int type)\r
//\r
\r
- //javadoc: Mat::create(size, type)\r
- public void create(Size size, int type)\r
+ // javadoc: Mat::create(size, type)\r
+ public void create(Size size, int type)\r
{\r
- \r
+\r
n_create(nativeObj, size.width, size.height, type);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::cross(Mat m)\r
+ // C++: Mat Mat::cross(Mat m)\r
//\r
\r
- //javadoc: Mat::cross(m)\r
- public Mat cross(Mat m)\r
+ // javadoc: Mat::cross(m)\r
+ public Mat cross(Mat m)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_cross(nativeObj, m.nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: long Mat::dataAddr()\r
+ // C++: long Mat::dataAddr()\r
//\r
\r
- //javadoc: Mat::dataAddr()\r
- public long dataAddr()\r
+ // javadoc: Mat::dataAddr()\r
+ public long dataAddr()\r
{\r
- \r
+\r
long retVal = n_dataAddr(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: int Mat::depth()\r
+ // C++: int Mat::depth()\r
//\r
\r
- //javadoc: Mat::depth()\r
- public int depth()\r
+ // javadoc: Mat::depth()\r
+ public int depth()\r
{\r
- \r
+\r
int retVal = n_depth(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::diag(int d = 0)\r
+ // C++: Mat Mat::diag(int d = 0)\r
//\r
\r
- //javadoc: Mat::diag(d)\r
- public Mat diag(int d)\r
+ // javadoc: Mat::diag(d)\r
+ public Mat diag(int d)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_diag(nativeObj, d));\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::diag()\r
- public Mat diag()\r
+ // javadoc: Mat::diag()\r
+ public Mat diag()\r
{\r
- \r
+\r
Mat retVal = new Mat(n_diag(nativeObj, 0));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::diag(Mat d)\r
//\r
\r
- //javadoc: Mat::diag(d)\r
+ // javadoc: Mat::diag(d)\r
public static Mat diag(Mat d)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_diag(d.nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: double Mat::dot(Mat m)\r
+ // C++: double Mat::dot(Mat m)\r
//\r
\r
- //javadoc: Mat::dot(m)\r
- public double dot(Mat m)\r
+ // javadoc: Mat::dot(m)\r
+ public double dot(Mat m)\r
{\r
- \r
+\r
double retVal = n_dot(nativeObj, m.nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: size_t Mat::elemSize()\r
+ // C++: size_t Mat::elemSize()\r
//\r
\r
- //javadoc: Mat::elemSize()\r
- public long elemSize()\r
+ // javadoc: Mat::elemSize()\r
+ public long elemSize()\r
{\r
- \r
+\r
long retVal = n_elemSize(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: size_t Mat::elemSize1()\r
+ // C++: size_t Mat::elemSize1()\r
//\r
\r
- //javadoc: Mat::elemSize1()\r
- public long elemSize1()\r
+ // javadoc: Mat::elemSize1()\r
+ public long elemSize1()\r
{\r
- \r
+\r
long retVal = n_elemSize1(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: bool Mat::empty()\r
+ // C++: bool Mat::empty()\r
//\r
\r
- //javadoc: Mat::empty()\r
- public boolean empty()\r
+ // javadoc: Mat::empty()\r
+ public boolean empty()\r
{\r
- \r
+\r
boolean retVal = n_empty(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::eye(int rows, int cols, int type)\r
//\r
\r
- //javadoc: Mat::eye(rows, cols, type)\r
+ // javadoc: Mat::eye(rows, cols, type)\r
public static Mat eye(int rows, int cols, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_eye(rows, cols, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::eye(Size size, int type)\r
//\r
\r
- //javadoc: Mat::eye(size, type)\r
+ // javadoc: Mat::eye(size, type)\r
public static Mat eye(Size size, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_eye(size.width, size.height, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::inv(int method = DECOMP_LU)\r
+ // C++: Mat Mat::inv(int method = DECOMP_LU)\r
//\r
\r
- //javadoc: Mat::inv(method)\r
- public Mat inv(int method)\r
+ // javadoc: Mat::inv(method)\r
+ public Mat inv(int method)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_inv(nativeObj, method));\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::inv()\r
- public Mat inv()\r
+ // javadoc: Mat::inv()\r
+ public Mat inv()\r
{\r
- \r
+\r
Mat retVal = new Mat(n_inv(nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: bool Mat::isContinuous()\r
+ // C++: bool Mat::isContinuous()\r
//\r
\r
- //javadoc: Mat::isContinuous()\r
- public boolean isContinuous()\r
+ // javadoc: Mat::isContinuous()\r
+ public boolean isContinuous()\r
{\r
- \r
+\r
boolean retVal = n_isContinuous(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: bool Mat::isSubmatrix()\r
+ // C++: bool Mat::isSubmatrix()\r
//\r
\r
- //javadoc: Mat::isSubmatrix()\r
- public boolean isSubmatrix()\r
+ // javadoc: Mat::isSubmatrix()\r
+ public boolean isSubmatrix()\r
{\r
- \r
+\r
boolean retVal = n_isSubmatrix(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: void Mat::locateROI(Size wholeSize, Point ofs)\r
+ // C++: void Mat::locateROI(Size wholeSize, Point ofs)\r
//\r
\r
- //javadoc: Mat::locateROI(wholeSize, ofs)\r
- public void locateROI(Size wholeSize, Point ofs)\r
+ // javadoc: Mat::locateROI(wholeSize, ofs)\r
+ public void locateROI(Size wholeSize, Point ofs)\r
{\r
- \r
+\r
n_locateROI(nativeObj, wholeSize.width, wholeSize.height, ofs.x, ofs.y);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::mul(Mat m, double scale = 1)\r
+ // C++: Mat Mat::mul(Mat m, double scale = 1)\r
//\r
\r
- //javadoc: Mat::mul(m, scale)\r
- public Mat mul(Mat m, double scale)\r
+ // javadoc: Mat::mul(m, scale)\r
+ public Mat mul(Mat m, double scale)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj, scale));\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::mul(m)\r
- public Mat mul(Mat m)\r
+ // javadoc: Mat::mul(m)\r
+ public Mat mul(Mat m)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_mul(nativeObj, m.nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::ones(int rows, int cols, int type)\r
//\r
\r
- //javadoc: Mat::ones(rows, cols, type)\r
+ // javadoc: Mat::ones(rows, cols, type)\r
public static Mat ones(int rows, int cols, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_ones(rows, cols, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::ones(Size size, int type)\r
//\r
\r
- //javadoc: Mat::ones(size, type)\r
+ // javadoc: Mat::ones(size, type)\r
public static Mat ones(Size size, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_ones(size.width, size.height, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: void Mat::push_back(Mat m)\r
+ // C++: void Mat::push_back(Mat m)\r
//\r
\r
- //javadoc: Mat::push_back(m)\r
- public void push_back(Mat m)\r
+ // javadoc: Mat::push_back(m)\r
+ public void push_back(Mat m)\r
{\r
- \r
+\r
n_push_back(nativeObj, m.nativeObj);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: void Mat::release()\r
+ // C++: void Mat::release()\r
//\r
\r
- //javadoc: Mat::release()\r
- public void release()\r
+ // javadoc: Mat::release()\r
+ public void release()\r
{\r
- \r
+\r
n_release(nativeObj);\r
- \r
+\r
return;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::reshape(int cn, int rows = 0)\r
+ // C++: Mat Mat::reshape(int cn, int rows = 0)\r
//\r
\r
- //javadoc: Mat::reshape(cn, rows)\r
- public Mat reshape(int cn, int rows)\r
+ // javadoc: Mat::reshape(cn, rows)\r
+ public Mat reshape(int cn, int rows)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_reshape(nativeObj, cn, rows));\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::reshape(cn)\r
- public Mat reshape(int cn)\r
+ // javadoc: Mat::reshape(cn)\r
+ public Mat reshape(int cn)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_reshape(nativeObj, cn));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::row(int y)\r
+ // C++: Mat Mat::row(int y)\r
//\r
\r
- //javadoc: Mat::row(y)\r
- public Mat row(int y)\r
+ // javadoc: Mat::row(y)\r
+ public Mat row(int y)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_row(nativeObj, y));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::rowRange(int startrow, int endrow)\r
+ // C++: Mat Mat::rowRange(int startrow, int endrow)\r
//\r
\r
- //javadoc: Mat::rowRange(startrow, endrow)\r
- public Mat rowRange(int startrow, int endrow)\r
+ // javadoc: Mat::rowRange(startrow, endrow)\r
+ public Mat rowRange(int startrow, int endrow)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_rowRange(nativeObj, startrow, endrow));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::rowRange(Range r)\r
+ // C++: Mat Mat::rowRange(Range r)\r
//\r
\r
- //javadoc: Mat::rowRange(r)\r
- public Mat rowRange(Range r)\r
+ // javadoc: Mat::rowRange(r)\r
+ public Mat rowRange(Range r)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_rowRange(nativeObj, r.start, r.end));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: int Mat::rows()\r
+ // C++: int Mat::rows()\r
//\r
\r
- //javadoc: Mat::rows()\r
- public int rows()\r
+ // javadoc: Mat::rows()\r
+ public int rows()\r
{\r
- \r
+\r
int retVal = n_rows(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::operator =(Scalar s)\r
+ // C++: Mat Mat::operator =(Scalar s)\r
//\r
\r
- //javadoc: Mat::operator =(s)\r
- public Mat setTo(Scalar s)\r
+ // javadoc: Mat::operator =(s)\r
+ public Mat setTo(Scalar s)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_setTo(nativeObj, s.val[0], s.val[1], s.val[2], s.val[3]));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())\r
+ // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())\r
//\r
\r
- //javadoc: Mat::setTo(value, mask)\r
- public Mat setTo(Mat value, Mat mask)\r
+ // javadoc: Mat::setTo(value, mask)\r
+ public Mat setTo(Mat value, Mat mask)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj, mask.nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::setTo(value)\r
- public Mat setTo(Mat value)\r
+ // javadoc: Mat::setTo(value)\r
+ public Mat setTo(Mat value)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_setTo(nativeObj, value.nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Size Mat::size()\r
+ // C++: Size Mat::size()\r
//\r
\r
- //javadoc: Mat::size()\r
- public Size size()\r
+ // javadoc: Mat::size()\r
+ public Size size()\r
{\r
- \r
+\r
Size retVal = new Size(n_size(nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: size_t Mat::step1(int i = 0)\r
+ // C++: size_t Mat::step1(int i = 0)\r
//\r
\r
- //javadoc: Mat::step1(i)\r
- public long step1(int i)\r
+ // javadoc: Mat::step1(i)\r
+ public long step1(int i)\r
{\r
- \r
+\r
long retVal = n_step1(nativeObj, i);\r
- \r
+\r
return retVal;\r
}\r
\r
- //javadoc: Mat::step1()\r
- public long step1()\r
+ // javadoc: Mat::step1()\r
+ public long step1()\r
{\r
- \r
+\r
long retVal = n_step1(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int colEnd)\r
+ // C++: Mat Mat::operator()(int rowStart, int rowEnd, int colStart, int\r
+ // colEnd)\r
//\r
\r
- //javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)\r
- public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)\r
+ // javadoc: Mat::operator()(rowStart, rowEnd, colStart, colEnd)\r
+ public Mat submat(int rowStart, int rowEnd, int colStart, int colEnd)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_submat_rr(nativeObj, rowStart, rowEnd, colStart, colEnd));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::operator()(Range rowRange, Range colRange)\r
+ // C++: Mat Mat::operator()(Range rowRange, Range colRange)\r
//\r
\r
- //javadoc: Mat::operator()(rowRange, colRange)\r
- public Mat submat(Range rowRange, Range colRange)\r
+ // javadoc: Mat::operator()(rowRange, colRange)\r
+ public Mat submat(Range rowRange, Range colRange)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_submat_rr(nativeObj, rowRange.start, rowRange.end, colRange.start, colRange.end));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::operator()(Rect roi)\r
+ // C++: Mat Mat::operator()(Rect roi)\r
//\r
\r
- //javadoc: Mat::operator()(roi)\r
- public Mat submat(Rect roi)\r
+ // javadoc: Mat::operator()(roi)\r
+ public Mat submat(Rect roi)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_submat(nativeObj, roi.x, roi.y, roi.width, roi.height));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: Mat Mat::t()\r
+ // C++: Mat Mat::t()\r
//\r
\r
- //javadoc: Mat::t()\r
- public Mat t()\r
+ // javadoc: Mat::t()\r
+ public Mat t()\r
{\r
- \r
+\r
Mat retVal = new Mat(n_t(nativeObj));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: size_t Mat::total()\r
+ // C++: size_t Mat::total()\r
//\r
\r
- //javadoc: Mat::total()\r
- public long total()\r
+ // javadoc: Mat::total()\r
+ public long total()\r
{\r
- \r
+\r
long retVal = n_total(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
- // C++: int Mat::type()\r
+ // C++: int Mat::type()\r
//\r
\r
- //javadoc: Mat::type()\r
- public int type()\r
+ // javadoc: Mat::type()\r
+ public int type()\r
{\r
- \r
+\r
int retVal = n_type(nativeObj);\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::zeros(int rows, int cols, int type)\r
//\r
\r
- //javadoc: Mat::zeros(rows, cols, type)\r
+ // javadoc: Mat::zeros(rows, cols, type)\r
public static Mat zeros(int rows, int cols, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_zeros(rows, cols, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
//\r
// C++: static Mat Mat::zeros(Size size, int type)\r
//\r
\r
- //javadoc: Mat::zeros(size, type)\r
+ // javadoc: Mat::zeros(size, type)\r
public static Mat zeros(Size size, int type)\r
{\r
- \r
+\r
Mat retVal = new Mat(n_zeros(size.width, size.height, type));\r
- \r
+\r
return retVal;\r
}\r
\r
-\r
@Override\r
protected void finalize() throws Throwable {\r
n_delete(nativeObj);\r
super.finalize();\r
}\r
- \r
- //javadoc:Mat::toString()\r
+\r
+ // javadoc:Mat::toString()\r
@Override\r
public String toString() {\r
- return "Mat [ " +\r
+ return "Mat [ " +\r
rows() + "*" + cols() + "*" + CvType.typeToString(type()) +\r
", isCont=" + isContinuous() + ", isSubmat=" + isSubmatrix() +\r
- ", nativeObj=0x" + Long.toHexString(nativeObj) + \r
- ", dataAddr=0x" + Long.toHexString(dataAddr()) + \r
+ ", nativeObj=0x" + Long.toHexString(nativeObj) +\r
+ ", dataAddr=0x" + Long.toHexString(dataAddr()) +\r
" ]";\r
}\r
\r
- //javadoc:Mat::dump()\r
+ // javadoc:Mat::dump()\r
public String dump() {\r
return nDump(nativeObj);\r
}\r
- \r
- //javadoc:Mat::put(row,col,data)\r
- public int put(int row, int col, double...data) {\r
+\r
+ // javadoc:Mat::put(row,col,data)\r
+ public int put(int row, int col, double... data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- return nPutD(nativeObj, row, col, data.length, data);\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ return nPutD(nativeObj, row, col, data.length, data);\r
}\r
\r
- //javadoc:Mat::put(row,col,data)\r
+ // javadoc:Mat::put(row,col,data)\r
public int put(int row, int col, float[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_32F) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_32F) {\r
return nPutF(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::put(row,col,data) \r
+ // javadoc:Mat::put(row,col,data)\r
public int put(int row, int col, int[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_32S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_32S) {\r
return nPutI(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
- \r
- //javadoc:Mat::put(row,col,data)\r
+\r
+ // javadoc:Mat::put(row,col,data)\r
public int put(int row, int col, short[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {\r
return nPutS(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
- \r
- //javadoc:Mat::put(row,col,data)\r
+\r
+ // javadoc:Mat::put(row,col,data)\r
public int put(int row, int col, byte[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {\r
return nPutB(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
- \r
- //javadoc:Mat::get(row,col,data)\r
+\r
+ // javadoc:Mat::get(row,col,data)\r
public int get(int row, int col, byte[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_8U || CvType.depth(t) == CvType.CV_8S) {\r
return nGetB(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::get(row,col,data)\r
+ // javadoc:Mat::get(row,col,data)\r
public int get(int row, int col, short[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_16U || CvType.depth(t) == CvType.CV_16S) {\r
return nGetS(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::get(row,col,data)\r
+ // javadoc:Mat::get(row,col,data)\r
public int get(int row, int col, int[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_32S) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_32S) {\r
return nGetI(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::get(row,col,data)\r
+ // javadoc:Mat::get(row,col,data)\r
public int get(int row, int col, float[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_32F) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_32F) {\r
return nGetF(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::get(row,col,data)\r
+ // javadoc:Mat::get(row,col,data)\r
public int get(int row, int col, double[] data) {\r
int t = type();\r
- if(data == null || data.length % CvType.channels(t) != 0)\r
- throw new java.lang.UnsupportedOperationException(\r
- "Provided data element number (" +\r
- (data == null ? 0 : data.length) + \r
- ") should be multiple of the Mat channels count (" +\r
- CvType.channels(t) + ")");\r
- if(CvType.depth(t) == CvType.CV_64F) {\r
+ if (data == null || data.length % CvType.channels(t) != 0)\r
+ throw new java.lang.UnsupportedOperationException(\r
+ "Provided data element number (" +\r
+ (data == null ? 0 : data.length) +\r
+ ") should be multiple of the Mat channels count (" +\r
+ CvType.channels(t) + ")");\r
+ if (CvType.depth(t) == CvType.CV_64F) {\r
return nGetD(nativeObj, row, col, data.length, data);\r
}\r
throw new java.lang.UnsupportedOperationException("Mat data type is not compatible: " + t);\r
}\r
\r
- //javadoc:Mat::get(row,col)\r
+ // javadoc:Mat::get(row,col)\r
public double[] get(int row, int col) {\r
return nGet(nativeObj, row, col);\r
}\r
\r
- //javadoc:Mat::height()\r
- public int height() { \r
- return rows(); \r
+ // javadoc:Mat::height()\r
+ public int height() {\r
+ return rows();\r
}\r
- \r
- //javadoc:Mat::width()\r
- public int width() { \r
- return cols(); \r
+\r
+ // javadoc:Mat::width()\r
+ public int width() {\r
+ return cols();\r
}\r
\r
- //javadoc:Mat::getNativeObjAddr()\r
+ // javadoc:Mat::getNativeObjAddr()\r
public long getNativeObjAddr() {\r
return nativeObj;\r
}\r
\r
-\r
//\r
// native stuff\r
//\r
- static { System.loadLibrary("opencv_java"); }\r
+ static {\r
+ System.loadLibrary("opencv_java");\r
+ }\r
\r
- // C++: Mat::Mat()\r
+ // C++: Mat::Mat()\r
private static native long n_Mat();\r
\r
- // C++: Mat::Mat(int rows, int cols, int type)\r
+ // C++: Mat::Mat(int rows, int cols, int type)\r
private static native long n_Mat(int rows, int cols, int type);\r
\r
- // C++: Mat::Mat(Size size, int type)\r
+ // C++: Mat::Mat(Size size, int type)\r
private static native long n_Mat(double size_width, double size_height, int type);\r
\r
- // C++: Mat::Mat(int rows, int cols, int type, Scalar s)\r
+ // C++: Mat::Mat(int rows, int cols, int type, Scalar s)\r
private static native long n_Mat(int rows, int cols, int type, double s_val0, double s_val1, double s_val2, double s_val3);\r
\r
- // C++: Mat::Mat(Size size, int type, Scalar s)\r
+ // C++: Mat::Mat(Size size, int type, Scalar s)\r
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);\r
\r
- // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())\r
+ // C++: Mat::Mat(Mat m, Range rowRange, Range colRange = Range::all())\r
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);\r
+\r
private static native long n_Mat(long m_nativeObj, int rowRange_start, int rowRange_end);\r
\r
- // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)\r
+ // C++: Mat Mat::adjustROI(int dtop, int dbottom, int dleft, int dright)\r
private static native long n_adjustROI(long nativeObj, int dtop, int dbottom, int dleft, int dright);\r
\r
- // C++: void Mat::assignTo(Mat m, int type = -1)\r
+ // C++: void Mat::assignTo(Mat m, int type = -1)\r
private static native void n_assignTo(long nativeObj, long m_nativeObj, int type);\r
+\r
private static native void n_assignTo(long nativeObj, long m_nativeObj);\r
\r
- // C++: int Mat::channels()\r
+ // C++: int Mat::channels()\r
private static native int n_channels(long nativeObj);\r
\r
- // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool requireContinuous = true)\r
+ // C++: int Mat::checkVector(int elemChannels, int depth = -1, bool\r
+ // requireContinuous = true)\r
private static native int n_checkVector(long nativeObj, int elemChannels, int depth, boolean requireContinuous);\r
+\r
private static native int n_checkVector(long nativeObj, int elemChannels, int depth);\r
+\r
private static native int n_checkVector(long nativeObj, int elemChannels);\r
\r
- // C++: Mat Mat::clone()\r
+ // C++: Mat Mat::clone()\r
private static native long n_clone(long nativeObj);\r
\r
- // C++: Mat Mat::col(int x)\r
+ // C++: Mat Mat::col(int x)\r
private static native long n_col(long nativeObj, int x);\r
\r
- // C++: Mat Mat::colRange(int startcol, int endcol)\r
+ // C++: Mat Mat::colRange(int startcol, int endcol)\r
private static native long n_colRange(long nativeObj, int startcol, int endcol);\r
\r
- // C++: int Mat::cols()\r
+ // C++: int Mat::cols()\r
private static native int n_cols(long nativeObj);\r
\r
- // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta = 0)\r
+ // C++: void Mat::convertTo(Mat& m, int rtype, double alpha = 1, double beta\r
+ // = 0)\r
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha, double beta);\r
+\r
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype, double alpha);\r
+\r
private static native void n_convertTo(long nativeObj, long m_nativeObj, int rtype);\r
\r
- // C++: void Mat::copyTo(Mat& m)\r
+ // C++: void Mat::copyTo(Mat& m)\r
private static native void n_copyTo(long nativeObj, long m_nativeObj);\r
\r
- // C++: void Mat::copyTo(Mat& m, Mat mask)\r
+ // C++: void Mat::copyTo(Mat& m, Mat mask)\r
private static native void n_copyTo(long nativeObj, long m_nativeObj, long mask_nativeObj);\r
\r
- // C++: void Mat::create(int rows, int cols, int type)\r
+ // C++: void Mat::create(int rows, int cols, int type)\r
private static native void n_create(long nativeObj, int rows, int cols, int type);\r
\r
- // C++: void Mat::create(Size size, int type)\r
+ // C++: void Mat::create(Size size, int type)\r
private static native void n_create(long nativeObj, double size_width, double size_height, int type);\r
\r
- // C++: Mat Mat::cross(Mat m)\r
+ // C++: Mat Mat::cross(Mat m)\r
private static native long n_cross(long nativeObj, long m_nativeObj);\r
\r
- // C++: long Mat::dataAddr()\r
+ // C++: long Mat::dataAddr()\r
private static native long n_dataAddr(long nativeObj);\r
\r
- // C++: int Mat::depth()\r
+ // C++: int Mat::depth()\r
private static native int n_depth(long nativeObj);\r
\r
- // C++: Mat Mat::diag(int d = 0)\r
+ // C++: Mat Mat::diag(int d = 0)\r
private static native long n_diag(long nativeObj, int d);\r
\r
// C++: static Mat Mat::diag(Mat d)\r
private static native long n_diag(long d_nativeObj);\r
\r
- // C++: double Mat::dot(Mat m)\r
+ // C++: double Mat::dot(Mat m)\r
private static native double n_dot(long nativeObj, long m_nativeObj);\r
\r
- // C++: size_t Mat::elemSize()\r
+ // C++: size_t Mat::elemSize()\r
private static native long n_elemSize(long nativeObj);\r
\r
- // C++: size_t Mat::elemSize1()\r
+ // C++: size_t Mat::elemSize1()\r
private static native long n_elemSize1(long nativeObj);\r
\r
- // C++: bool Mat::empty()\r
+ // C++: bool Mat::empty()\r
private static native boolean n_empty(long nativeObj);\r
\r
// C++: static Mat Mat::eye(int rows, int cols, int type)\r
// C++: static Mat Mat::eye(Size size, int type)\r
private static native long n_eye(double size_width, double size_height, int type);\r
\r
- // C++: Mat Mat::inv(int method = DECOMP_LU)\r
+ // C++: Mat Mat::inv(int method = DECOMP_LU)\r
private static native long n_inv(long nativeObj, int method);\r
+\r
private static native long n_inv(long nativeObj);\r
\r
- // C++: bool Mat::isContinuous()\r
+ // C++: bool Mat::isContinuous()\r
private static native boolean n_isContinuous(long nativeObj);\r
\r
- // C++: bool Mat::isSubmatrix()\r
+ // C++: bool Mat::isSubmatrix()\r
private static native boolean n_isSubmatrix(long nativeObj);\r
\r
- // C++: void Mat::locateROI(Size wholeSize, Point ofs)\r
+ // C++: void Mat::locateROI(Size wholeSize, Point ofs)\r
private static native void n_locateROI(long nativeObj, double wholeSize_width, double wholeSize_height, double ofs_x, double ofs_y);\r
\r
- // C++: Mat Mat::mul(Mat m, double scale = 1)\r
+ // C++: Mat Mat::mul(Mat m, double scale = 1)\r
private static native long n_mul(long nativeObj, long m_nativeObj, double scale);\r
+\r
private static native long n_mul(long nativeObj, long m_nativeObj);\r
\r
// C++: static Mat Mat::ones(int rows, int cols, int type)\r
// C++: static Mat Mat::ones(Size size, int type)\r
private static native long n_ones(double size_width, double size_height, int type);\r
\r
- // C++: void Mat::push_back(Mat m)\r
+ // C++: void Mat::push_back(Mat m)\r
private static native void n_push_back(long nativeObj, long m_nativeObj);\r
\r
- // C++: void Mat::release()\r
+ // C++: void Mat::release()\r
private static native void n_release(long nativeObj);\r
\r
- // C++: Mat Mat::reshape(int cn, int rows = 0)\r
+ // C++: Mat Mat::reshape(int cn, int rows = 0)\r
private static native long n_reshape(long nativeObj, int cn, int rows);\r
+\r
private static native long n_reshape(long nativeObj, int cn);\r
\r
- // C++: Mat Mat::row(int y)\r
+ // C++: Mat Mat::row(int y)\r
private static native long n_row(long nativeObj, int y);\r
\r
- // C++: Mat Mat::rowRange(int startrow, int endrow)\r
+ // C++: Mat Mat::rowRange(int startrow, int endrow)\r
private static native long n_rowRange(long nativeObj, int startrow, int endrow);\r
\r
- // C++: int Mat::rows()\r
+ // C++: int Mat::rows()\r
private static native int n_rows(long nativeObj);\r
\r
- // C++: Mat Mat::operator =(Scalar s)\r
+ // C++: Mat Mat::operator =(Scalar s)\r
private static native long n_setTo(long nativeObj, double s_val0, double s_val1, double s_val2, double s_val3);\r
\r
- // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())\r
+ // C++: Mat Mat::setTo(Mat value, Mat mask = Mat())\r
private static native long n_setTo(long nativeObj, long value_nativeObj, long mask_nativeObj);\r
+\r
private static native long n_setTo(long nativeObj, long value_nativeObj);\r
\r
- // C++: Size Mat::size()\r
+ // C++: Size Mat::size()\r
private static native double[] n_size(long nativeObj);\r
\r
- // C++: size_t Mat::step1(int i = 0)\r
+ // C++: size_t Mat::step1(int i = 0)\r
private static native long n_step1(long nativeObj, int i);\r
+\r
private static native long n_step1(long nativeObj);\r
- \r
- // C++: Mat Mat::operator()(Range rowRange, Range colRange)\r
+\r
+ // C++: Mat Mat::operator()(Range rowRange, Range colRange)\r
private static native long n_submat_rr(long nativeObj, int rowRange_start, int rowRange_end, int colRange_start, int colRange_end);\r
\r
- // C++: Mat Mat::operator()(Rect roi)\r
+ // C++: Mat Mat::operator()(Rect roi)\r
private static native long n_submat(long nativeObj, int roi_x, int roi_y, int roi_width, int roi_height);\r
\r
- // C++: Mat Mat::t()\r
+ // C++: Mat Mat::t()\r
private static native long n_t(long nativeObj);\r
\r
- // C++: size_t Mat::total()\r
+ // C++: size_t Mat::total()\r
private static native long n_total(long nativeObj);\r
\r
- // C++: int Mat::type()\r
+ // C++: int Mat::type()\r
private static native int n_type(long nativeObj);\r
\r
// C++: static Mat Mat::zeros(int rows, int cols, int type)\r
\r
// native support for java finalize()\r
private static native void n_delete(long nativeObj);\r
- \r
- \r
+\r
private static native int nPutD(long self, int row, int col, int count, double[] data);\r
+\r
private static native int nPutF(long self, int row, int col, int count, float[] data);\r
+\r
private static native int nPutI(long self, int row, int col, int count, int[] data);\r
+\r
private static native int nPutS(long self, int row, int col, int count, short[] data);\r
+\r
private static native int nPutB(long self, int row, int col, int count, byte[] data);\r
+\r
private static native int nGetB(long self, int row, int col, int count, byte[] vals);\r
+\r
private static native int nGetS(long self, int row, int col, int count, short[] vals);\r
+\r
private static native int nGetI(long self, int row, int col, int count, int[] vals);\r
+\r
private static native int nGetF(long self, int row, int col, int count, float[] vals);\r
+\r
private static native int nGetD(long self, int row, int col, int count, double[] vals);\r
+\r
private static native double[] nGet(long self, int row, int col);\r
+\r
private static native String nDump(long self);\r
}\r
this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- x = vals.length>0 ? vals[0] : 0;\r
- y = vals.length>1 ? vals[1] : 0;\r
+ if (vals != null) {\r
+ x = vals.length > 0 ? vals[0] : 0;\r
+ y = vals.length > 1 ? vals[1] : 0;\r
} else {\r
x = 0;\r
y = 0;\r
- }\r
+ }\r
}\r
\r
-\r
public Point clone() {\r
return new Point(x, y);\r
}\r
@Override\r
public boolean equals(Object obj) {\r
if (this == obj) return true;\r
- if ( ! (obj instanceof Point) ) return false;\r
+ if (!(obj instanceof Point)) return false;\r
Point it = (Point) obj;\r
return x == it.x && y == it.y;\r
}\r
return r.contains(this);\r
}\r
\r
-\r
@Override\r
public String toString() {\r
- if (this == null) return "null";\r
return "{" + x + ", " + y + "}";\r
}\r
}\r
this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- x = vals.length>0 ? vals[0] : 0;\r
- y = vals.length>1 ? vals[1] : 0;\r
- z = vals.length>2 ? vals[2] : 0;\r
+ if (vals != null) {\r
+ x = vals.length > 0 ? vals[0] : 0;\r
+ y = vals.length > 1 ? vals[1] : 0;\r
+ z = vals.length > 2 ? vals[2] : 0;\r
} else {\r
x = 0;\r
y = 0;\r
z = 0;\r
- }\r
+ }\r
}\r
\r
public Point3 clone() {\r
Point3 it = (Point3) obj;\r
return x == it.x && y == it.y && z == it.z;\r
}\r
+ \r
+ @Override\r
+ public String toString() {\r
+ return "{" + x + ", " + y + ", " + z + "}";\r
+ }\r
}\r
\r
//javadoc:Range\r
public class Range {\r
- \r
+\r
public int start, end;\r
\r
public Range(int s, int e) {\r
public Range() {\r
this(0, 0);\r
}\r
+\r
public Range(double[] vals) {\r
- this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- start = vals.length>0 ? (int)vals[0] : 0;\r
- end = vals.length>1 ? (int)vals[1] : 0;\r
+ if (vals != null) {\r
+ start = vals.length > 0 ? (int) vals[0] : 0;\r
+ end = vals.length > 1 ? (int) vals[1] : 0;\r
} else {\r
start = 0;\r
- end = 0;\r
- }\r
+ end = 0;\r
+ }\r
\r
}\r
\r
public int size() {\r
- return end-start;\r
+ return empty() ? 0 : end - start;\r
}\r
\r
public boolean empty() {\r
- return start==end;\r
+ return end <= start;\r
}\r
\r
public static Range all() {\r
- return new Range(Integer.MIN_VALUE , Integer.MAX_VALUE);\r
+ return new Range(Integer.MIN_VALUE, Integer.MAX_VALUE);\r
}\r
\r
public Range intersection(Range r1) {\r
r.end = Math.max(r.end, r.start);\r
return r;\r
}\r
+\r
public Range shift(int delta) {\r
- return new Range(start+delta, end+delta);\r
+ return new Range(start + delta, end + delta);\r
}\r
- \r
- \r
+\r
public Range clone() {\r
return new Range(start, end);\r
}\r
- \r
+\r
@Override\r
public int hashCode() {\r
final int prime = 31;\r
\r
@Override\r
public String toString() {\r
- if (this == null) return "null";\r
return "[" + start + ", " + end + ")";\r
}\r
}\r
}\r
\r
public Rect(Point p, Size s) {\r
- this((int)p.x, (int)p.y, (int)s.width, (int)s.height);\r
+ this((int) p.x, (int) p.y, (int) s.width, (int) s.height);\r
}\r
\r
public Rect(double[] vals) {\r
- this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- x = vals.length>0 ? (int)vals[0] : 0;\r
- y = vals.length>1 ? (int)vals[1] : 0;\r
- width = vals.length>2 ? (int)vals[2] : 0;\r
- height = vals.length>3 ? (int)vals[3] : 0;\r
+ if (vals != null) {\r
+ x = vals.length > 0 ? (int) vals[0] : 0;\r
+ y = vals.length > 1 ? (int) vals[1] : 0;\r
+ width = vals.length > 2 ? (int) vals[2] : 0;\r
+ height = vals.length > 3 ? (int) vals[3] : 0;\r
} else {\r
- x = 0;\r
- y = 0;\r
- width = 0;\r
+ x = 0;\r
+ y = 0;\r
+ width = 0;\r
height = 0;\r
- }\r
+ }\r
}\r
\r
public Rect clone() {\r
\r
@Override\r
public String toString() {\r
- if (this == null) return "null";\r
- return "{" + x + ", " + y + ", " + width + "x" + height+"}";\r
+ return "{" + x + ", " + y + ", " + width + "x" + height + "}";\r
}\r
}\r
this();\r
set(vals);\r
}\r
- \r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- center.x = vals.length>0 ? (double)vals[0] : 0;\r
- center.y = vals.length>1 ? (double)vals[1] : 0;\r
- size.width = vals.length>2 ? (double)vals[2] : 0;\r
- size.height = vals.length>3 ? (double)vals[3] : 0;\r
- angle = vals.length>4 ? (double)vals[4] : 0;\r
+ if (vals != null) {\r
+ center.x = vals.length > 0 ? (double) vals[0] : 0;\r
+ center.y = vals.length > 1 ? (double) vals[1] : 0;\r
+ size.width = vals.length > 2 ? (double) vals[2] : 0;\r
+ size.height = vals.length > 3 ? (double) vals[3] : 0;\r
+ angle = vals.length > 4 ? (double) vals[4] : 0;\r
} else {\r
- center.x = 0;\r
- center.x = 0;\r
- size.width = 0;\r
+ center.x = 0;\r
+ center.x = 0;\r
+ size.width = 0;\r
size.height = 0;\r
- angle = 0;\r
+ angle = 0;\r
}\r
}\r
\r
public void points(Point pt[])\r
{\r
- double _angle = angle*Math.PI/180.0;\r
- double b = (double)Math.cos(_angle)*0.5f;\r
- double a = (double)Math.sin(_angle)*0.5f;\r
+ double _angle = angle * Math.PI / 180.0;\r
+ double b = (double) Math.cos(_angle) * 0.5f;\r
+ double a = (double) Math.sin(_angle) * 0.5f;\r
\r
pt[0] = new Point(\r
- center.x - a*size.height - b*size.width,\r
- center.y + b*size.height - a*size.width);\r
+ center.x - a * size.height - b * size.width,\r
+ center.y + b * size.height - a * size.width);\r
\r
pt[1] = new Point(\r
- center.x + a*size.height - b*size.width,\r
- center.y - b*size.height - a*size.width);\r
+ center.x + a * size.height - b * size.width,\r
+ center.y - b * size.height - a * size.width);\r
\r
pt[2] = new Point(\r
- 2*center.x - pt[0].x,\r
- 2*center.y - pt[0].y);\r
+ 2 * center.x - pt[0].x,\r
+ 2 * center.y - pt[0].y);\r
\r
pt[3] = new Point(\r
- 2*center.x - pt[1].x,\r
- 2*center.y - pt[1].y);\r
+ 2 * center.x - pt[1].x,\r
+ 2 * center.y - pt[1].y);\r
}\r
\r
public Rect boundingRect()\r
{\r
Point pt[] = new Point[4];\r
points(pt);\r
- 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)),\r
- (int)Math.floor(Math.min(Math.min(Math.min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)),\r
- (int)Math.ceil(Math.max(Math.max(Math.max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),\r
- (int)Math.ceil(Math.max(Math.max(Math.max(pt[0].y, pt[1].y), pt[2].y), pt[3].y)));\r
+ 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)),\r
+ (int) Math.floor(Math.min(Math.min(Math.min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)),\r
+ (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),\r
+ (int) Math.ceil(Math.max(Math.max(Math.max(pt[0].y, pt[1].y), pt[2].y), pt[3].y)));\r
r.width -= r.x - 1;\r
r.height -= r.y - 1;\r
return r;\r
RotatedRect it = (RotatedRect) obj;\r
return center.equals(it.center) && size.equals(it.size) && angle == it.angle;\r
}\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "{ " + center + " " + size + " * " + angle + " }";\r
+ }\r
}\r
public double val[];\r
\r
public Scalar(double v0, double v1, double v2, double v3) {\r
- this.val = new double[] {v0, v1, v2, v3};\r
+ val = new double[] { v0, v1, v2, v3 };\r
}\r
\r
public Scalar(double v0, double v1, double v2) {\r
- this.val = new double[] {v0, v1, v2, 0};\r
+ val = new double[] { v0, v1, v2, 0 };\r
}\r
\r
public Scalar(double v0, double v1) {\r
- this.val = new double[] {v0, v1, 0, 0};\r
+ val = new double[] { v0, v1, 0, 0 };\r
}\r
\r
public Scalar(double v0) {\r
- this.val = new double[] {v0, 0, 0, 0};\r
+ val = new double[] { v0, 0, 0, 0 };\r
}\r
\r
public Scalar(double[] vals) {\r
- this.val = new double[4];\r
- set(vals);\r
+ if (vals != null && vals.length == 4)\r
+ val = vals.clone();\r
+ else {\r
+ val = new double[4];\r
+ set(vals);\r
+ }\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- this.val[0] = vals.length>0 ? vals[0] : 0;\r
- this.val[1] = vals.length>1 ? vals[1] : 0;\r
- this.val[2] = vals.length>2 ? vals[2] : 0;\r
- this.val[3] = vals.length>3 ? vals[3] : 0;\r
- }\r
+ if (vals != null) {\r
+ val[0] = vals.length > 0 ? vals[0] : 0;\r
+ val[1] = vals.length > 1 ? vals[1] : 0;\r
+ val[2] = vals.length > 2 ? vals[2] : 0;\r
+ val[3] = vals.length > 3 ? vals[3] : 0;\r
+ } else\r
+ val[0] = val[1] = val[2] = val[3] = 0;\r
}\r
\r
public static Scalar all(double v) {\r
}\r
\r
public Scalar mul(Scalar it, double scale) {\r
- return new Scalar( val[0] * it.val[0] * scale, val[1] * it.val[1] * scale,\r
- val[2] * it.val[2] * scale, val[3] * it.val[3] * scale );\r
+ return new Scalar(val[0] * it.val[0] * scale, val[1] * it.val[1] * scale,\r
+ val[2] * it.val[2] * scale, val[3] * it.val[3] * scale);\r
}\r
\r
public Scalar mul(Scalar it) {\r
return mul(it, 1);\r
}\r
+\r
public Scalar conj() {\r
return new Scalar(val[0], -val[1], -val[2], -val[3]);\r
}\r
return val[1] == 0 && val[2] == 0 && val[3] == 0;\r
}\r
\r
- @Override\r
- public int hashCode() {\r
- final int prime = 31;\r
- int result = 1;\r
- result = prime * result + java.util.Arrays.hashCode(val);\r
- return result;\r
- }\r
-\r
- @Override\r
- public boolean equals(Object obj) {\r
- if (this == obj) return true;\r
- if (!(obj instanceof Scalar)) return false;\r
- Scalar it = (Scalar) obj;\r
- if (!java.util.Arrays.equals(val, it.val)) return false;\r
- return true;\r
- }\r
-\r
- \r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + java.util.Arrays.hashCode(val);\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof Scalar)) return false;\r
+ Scalar it = (Scalar) obj;\r
+ if (!java.util.Arrays.equals(val, it.val)) return false;\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "[" + val[0] + ", " + val[1] + ", " + val[2] + ", " + val[3] + "]";\r
+ }\r
+\r
}\r
}\r
\r
public Size(Point p) {\r
- width = (double) p.x;\r
- height = (double) p.y;\r
+ width = p.x;\r
+ height = p.y;\r
}\r
\r
public Size(double[] vals) {\r
- this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- width = vals.length>0 ? vals[0] : 0;\r
- height = vals.length>1 ? vals[1] : 0;\r
+ if (vals != null) {\r
+ width = vals.length > 0 ? vals[0] : 0;\r
+ height = vals.length > 1 ? vals[1] : 0;\r
} else {\r
- width = 0;\r
+ width = 0;\r
height = 0;\r
}\r
}\r
return width == it.width && height == it.height;\r
}\r
\r
+ @Override\r
+ public String toString() {\r
+ return (int)width + "x" + (int)height;\r
+ }\r
+\r
}\r
//javadoc:TermCriteria\r
public class TermCriteria {\r
\r
+ /**\r
+ * the maximum number of iterations or elements to compute\r
+ */\r
+ public static final int COUNT = 1;\r
+ /**\r
+ * the maximum number of iterations or elements to compute\r
+ */\r
+ public static final int MAX_ITER = COUNT;\r
+ /**\r
+ * the desired accuracy or change in parameters at which the iterative algorithm stops\r
+ */\r
+ public static final int EPS = 2;\r
+\r
public int type;\r
public int maxCount;\r
public double epsilon;\r
\r
- public TermCriteria(int t, int c, double e) {\r
- this.type = t;\r
- this.maxCount = c;\r
- this.epsilon = e;\r
+ /**\r
+ * Termination criteria in iterative algorithms\r
+ * \r
+ * @param type\r
+ * the type of termination criteria: COUNT, EPS or COUNT + EPS\r
+ * @param maxCount\r
+ * the maximum number of iterations/elements\r
+ * @param epsilon\r
+ * the desired accuracy\r
+ */\r
+ public TermCriteria(int type, int maxCount, double epsilon) {\r
+ this.type = type;\r
+ this.maxCount = maxCount;\r
+ this.epsilon = epsilon;\r
}\r
\r
+ /**\r
+ * Termination criteria in iterative algorithms\r
+ */\r
public TermCriteria() {\r
this(0, 0, 0.0);\r
}\r
\r
public TermCriteria(double[] vals) {\r
- this();\r
set(vals);\r
}\r
+\r
public void set(double[] vals) {\r
- if(vals!=null) {\r
- type = vals.length>0 ? (int)vals[0] : 0;\r
- maxCount = vals.length>1 ? (int)vals[1] : 0;\r
- epsilon = vals.length>2 ? (double)vals[2] : 0;\r
+ if (vals != null) {\r
+ type = vals.length > 0 ? (int) vals[0] : 0;\r
+ maxCount = vals.length > 1 ? (int) vals[1] : 0;\r
+ epsilon = vals.length > 2 ? (double) vals[2] : 0;\r
} else {\r
- type = 0;\r
- maxCount = 0;\r
- epsilon = 0;\r
+ type = 0;\r
+ maxCount = 0;\r
+ epsilon = 0;\r
}\r
}\r
\r
if (this == obj) return true;\r
if (!(obj instanceof TermCriteria)) return false;\r
TermCriteria it = (TermCriteria) obj;\r
- return type == it.type && maxCount == it.maxCount && epsilon== it.epsilon;\r
+ return type == it.type && maxCount == it.maxCount && epsilon == it.epsilon;\r
}\r
\r
@Override\r
package org.opencv.features2d;\r
\r
//C++: class DMatch\r
-//javadoc: DMatch\r
+\r
+/**\r
+ * Struct for matching: query descriptor index, train descriptor index, train\r
+ * image index and distance between descriptors.\r
+ */\r
public class DMatch {\r
- \r
- //javadoc: DMatch::queryIdx\r
- public int queryIdx;\r
- //javadoc: DMatch::trainIdx\r
- public int trainIdx;\r
- //javadoc: DMatch::imgIdx\r
- public int imgIdx;\r
- //javadoc: DMatch::distance\r
- public float distance;\r
- \r
- \r
- //javadoc: DMatch::DMatch()\r
+\r
+ /**\r
+ * query descriptor index\r
+ */\r
+ public int queryIdx;\r
+ /**\r
+ * train descriptor index\r
+ */\r
+ public int trainIdx;\r
+ /**\r
+ * train image index\r
+ */\r
+ public int imgIdx;\r
+\r
+ // javadoc: DMatch::distance\r
+ public float distance;\r
+\r
+ // javadoc: DMatch::DMatch()\r
public DMatch() {\r
- this(-1, -1, Float.MAX_VALUE);\r
- }\r
- \r
- \r
- public DMatch( int _queryIdx, int _trainIdx, float _distance ) {\r
- queryIdx = _queryIdx;\r
- trainIdx = _trainIdx;\r
- imgIdx = -1;\r
- distance = _distance; \r
+ this(-1, -1, Float.MAX_VALUE);\r
}\r
- \r
- \r
- public DMatch( int _queryIdx, int _trainIdx, int _imgIdx, float _distance ) {\r
- queryIdx = _queryIdx;\r
- trainIdx = _trainIdx;\r
- imgIdx = _imgIdx;\r
- distance = _distance; \r
+\r
+ // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _distance)\r
+ public DMatch(int _queryIdx, int _trainIdx, float _distance) {\r
+ queryIdx = _queryIdx;\r
+ trainIdx = _trainIdx;\r
+ imgIdx = -1;\r
+ distance = _distance;\r
}\r
\r
- // less is better\r
+ // javadoc: DMatch::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance)\r
+ public DMatch(int _queryIdx, int _trainIdx, int _imgIdx, float _distance) {\r
+ queryIdx = _queryIdx;\r
+ trainIdx = _trainIdx;\r
+ imgIdx = _imgIdx;\r
+ distance = _distance;\r
+ }\r
+\r
+ /**\r
+ * less is better\r
+ */\r
boolean lessThan(DMatch it) {\r
return distance < it.distance;\r
}\r
\r
-\r
- @Override\r
- public String toString() {\r
- return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx\r
- + ", imgIdx=" + imgIdx + ", distance=" + distance + "]";\r
- }\r
+ @Override\r
+ public String toString() {\r
+ return "DMatch [queryIdx=" + queryIdx + ", trainIdx=" + trainIdx\r
+ + ", imgIdx=" + imgIdx + ", distance=" + distance + "]";\r
+ }\r
\r
}\r
\r
//javadoc: KeyPoint\r
public class KeyPoint {\r
- \r
- //javadoc: KeyPoint::pt\r
+\r
+ /**\r
+ * coordinates of the keypoint\r
+ */\r
public Point pt;\r
- //javadoc: KeyPoint::size\r
+ /**\r
+ * diameter of the meaningful keypoint neighborhood\r
+ */\r
public float size;\r
- //javadoc: KeyPoint::angle\r
+ /**\r
+ * computed orientation of the keypoint (-1 if not applicable)\r
+ */\r
public float angle;\r
- //javadoc: KeyPoint::response\r
+ /**\r
+ * the response by which the most strong keypoints have been selected. Can\r
+ * be used for further sorting or subsampling\r
+ */\r
public float response;\r
- //javadoc: KeyPoint::octave\r
+ /**\r
+ * octave (pyramid layer) from which the keypoint has been extracted\r
+ */\r
public int octave;\r
- //javadoc: KeyPoint::class_id\r
- public int class_id; \r
+ /**\r
+ * object id that can be used to clustered keypoints by an object they\r
+ * belong to\r
+ */\r
+ public int class_id;\r
\r
- //javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave, _class_id)\r
+ // javadoc:KeyPoint::KeyPoint(x,y,_size,_angle,_response,_octave,_class_id)\r
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)\r
{\r
- pt = new Point(x, y);\r
- size = _size;\r
- angle = _angle;\r
- response = _response;\r
- octave = _octave;\r
- class_id = _class_id;\r
+ pt = new Point(x, y);\r
+ size = _size;\r
+ angle = _angle;\r
+ response = _response;\r
+ octave = _octave;\r
+ class_id = _class_id;\r
}\r
\r
- //javadoc: KeyPoint::KeyPoint()\r
+ // javadoc: KeyPoint::KeyPoint()\r
public KeyPoint()\r
{\r
- this(0, 0, 0, -1, 0, 0, -1);\r
+ this(0, 0, 0, -1, 0, 0, -1);\r
}\r
\r
- //javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave)\r
+ // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response, _octave)\r
public KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave)\r
{\r
- this(x, y, _size, _angle, _response, _octave, -1);\r
+ this(x, y, _size, _angle, _response, _octave, -1);\r
}\r
\r
- //javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response)\r
+ // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle, _response)\r
public KeyPoint(float x, float y, float _size, float _angle, float _response)\r
{\r
- this(x, y, _size, _angle, _response, 0, -1);\r
+ this(x, y, _size, _angle, _response, 0, -1);\r
}\r
\r
- //javadoc: KeyPoint::KeyPoint(x, y, _size, _angle)\r
+ // javadoc: KeyPoint::KeyPoint(x, y, _size, _angle)\r
public KeyPoint(float x, float y, float _size, float _angle)\r
{\r
- this(x, y, _size, _angle, 0, 0, -1);\r
+ this(x, y, _size, _angle, 0, 0, -1);\r
}\r
\r
- //javadoc: KeyPoint::KeyPoint(x, y, _size)\r
+ // javadoc: KeyPoint::KeyPoint(x, y, _size)\r
public KeyPoint(float x, float y, float _size)\r
{\r
- this(x, y, _size, -1, 0, 0, -1);\r
+ this(x, y, _size, -1, 0, 0, -1);\r
}\r
\r
- @Override\r
- public String toString() {\r
- return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle\r
- + ", response=" + response + ", octave=" + octave\r
- + ", class_id=" + class_id + "]";\r
- }\r
+ @Override\r
+ public String toString() {\r
+ return "KeyPoint [pt=" + pt + ", size=" + size + ", angle=" + angle\r
+ + ", response=" + response + ", octave=" + octave\r
+ + ", class_id=" + class_id + "]";\r
+ }\r
\r
}\r
public class VideoCapture {
protected final long nativeObj;
- protected VideoCapture(long addr) { nativeObj = addr; }
+ protected VideoCapture(long addr) {
+ nativeObj = addr;
+ }
//
- // C++: VideoCapture::VideoCapture()
+ // C++: VideoCapture::VideoCapture()
//
- //javadoc: VideoCapture::VideoCapture()
- public VideoCapture()
+ // javadoc: VideoCapture::VideoCapture()
+ public VideoCapture()
{
-
+
nativeObj = n_VideoCapture();
-
+
return;
}
-
//
- // C++: VideoCapture::VideoCapture(int device)
+ // C++: VideoCapture::VideoCapture(int device)
//
- //javadoc: VideoCapture::VideoCapture(device)
- public VideoCapture(int device)
+ // javadoc: VideoCapture::VideoCapture(device)
+ public VideoCapture(int device)
{
-
+
nativeObj = n_VideoCapture(device);
-
+
return;
}
-
-
//
- // C++: double VideoCapture::get(int propId)
+ // C++: double VideoCapture::get(int propId)
//
- //javadoc: VideoCapture::get(propId)
- public double 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()
+ public List<Size> getSupportedPreviewSizes()
{
String[] sizes_str = n_getSupportedPreviewSizes(nativeObj).split(",");
List<Size> sizes = new LinkedList<Size>();
- for(String str : sizes_str){
+ 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()
+ // C++: bool VideoCapture::grab()
//
- //javadoc: VideoCapture::grab()
- public boolean grab()
+ // javadoc: VideoCapture::grab()
+ public boolean grab()
{
-
+
boolean retVal = n_grab(nativeObj);
-
+
return retVal;
}
-
//
- // C++: bool VideoCapture::isOpened()
+ // C++: bool VideoCapture::isOpened()
//
- //javadoc: VideoCapture::isOpened()
- public boolean isOpened()
+ // javadoc: VideoCapture::isOpened()
+ public boolean isOpened()
{
-
+
boolean retVal = n_isOpened(nativeObj);
-
+
return retVal;
}
-
//
- // C++: bool VideoCapture::open(int device)
+ // C++: bool VideoCapture::open(int device)
//
- //javadoc: VideoCapture::open(device)
- public boolean 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)
+ // C++: bool VideoCapture::read(Mat image)
//
- //javadoc: VideoCapture::read(image)
- public boolean 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()
+ // C++: void VideoCapture::release()
//
- //javadoc: VideoCapture::release()
- public void release()
+ // javadoc: VideoCapture::release()
+ public void release()
{
-
+
n_release(nativeObj);
-
+
return;
}
-
//
- // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+ // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
//
- //javadoc: VideoCapture::retrieve(image, channel)
- public boolean retrieve(Mat image, int channel)
+ // 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)
+ // 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)
+ // C++: bool VideoCapture::set(int propId, double value)
//
- //javadoc: VideoCapture::set(propId, value)
- public boolean 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);
// native stuff
- static { System.loadLibrary("opencv_java"); }
+ static {
+ System.loadLibrary("opencv_java");
+ }
- // C++: VideoCapture::VideoCapture()
+ // C++: VideoCapture::VideoCapture()
private static native long n_VideoCapture();
- // C++: VideoCapture::VideoCapture(string filename)
+ // C++: VideoCapture::VideoCapture(string filename)
private static native long n_VideoCapture(java.lang.String filename);
- // C++: VideoCapture::VideoCapture(int device)
+ // C++: VideoCapture::VideoCapture(int device)
private static native long n_VideoCapture(int device);
- // C++: double VideoCapture::get(int propId)
+ // C++: double VideoCapture::get(int propId)
private static native double n_get(long nativeObj, int propId);
- // C++: bool VideoCapture::grab()
+ // C++: bool VideoCapture::grab()
private static native boolean n_grab(long nativeObj);
- // C++: bool VideoCapture::isOpened()
+ // C++: bool VideoCapture::isOpened()
private static native boolean n_isOpened(long nativeObj);
- // C++: bool VideoCapture::open(string filename)
+ // C++: bool VideoCapture::open(string filename)
private static native boolean n_open(long nativeObj, java.lang.String filename);
- // C++: bool VideoCapture::open(int device)
+ // C++: bool VideoCapture::open(int device)
private static native boolean n_open(long nativeObj, int device);
- // C++: bool VideoCapture::read(Mat image)
+ // C++: bool VideoCapture::read(Mat image)
private static native boolean n_read(long nativeObj, long image_nativeObj);
- // C++: void VideoCapture::release()
+ // C++: void VideoCapture::release()
private static native void n_release(long nativeObj);
- // C++: bool VideoCapture::retrieve(Mat image, int channel = 0)
+ // 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)
+ // 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);
\r
public static Mat vector_Point_to_Mat(List<Point> pts, int typeDepth) {\r
Mat res;\r
- int count = (pts!=null) ? pts.size() : 0;\r
- if(count>0){\r
+ int count = (pts != null) ? pts.size() : 0;\r
+ if (count > 0) {\r
switch (typeDepth) {\r
- case CvType.CV_32S:\r
- {\r
- res = new Mat(count, 1, CvType.CV_32SC2);\r
- int[] buff = new int[count*2];\r
- for(int i=0; i<count; i++) {\r
- Point p = pts.get(i);\r
- buff[i*2] = (int)p.x;\r
- buff[i*2+1] = (int)p.y;\r
- }\r
- res.put(0, 0, buff);\r
+ case CvType.CV_32S: {\r
+ res = new Mat(count, 1, CvType.CV_32SC2);\r
+ int[] buff = new int[count * 2];\r
+ for (int i = 0; i < count; i++) {\r
+ Point p = pts.get(i);\r
+ buff[i * 2] = (int) p.x;\r
+ buff[i * 2 + 1] = (int) p.y;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- case CvType.CV_32F:\r
- {\r
- res = new Mat(count, 1, CvType.CV_32FC2);\r
- float[] buff = new float[count*2];\r
- for(int i=0; i<count; i++) {\r
- Point p = pts.get(i);\r
- buff[i*2] = (float)p.x;\r
- buff[i*2+1] = (float)p.y;\r
- }\r
- res.put(0, 0, buff);\r
+ case CvType.CV_32F: {\r
+ res = new Mat(count, 1, CvType.CV_32FC2);\r
+ float[] buff = new float[count * 2];\r
+ for (int i = 0; i < count; i++) {\r
+ Point p = pts.get(i);\r
+ buff[i * 2] = (float) p.x;\r
+ buff[i * 2 + 1] = (float) p.y;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- case CvType.CV_64F:\r
- {\r
- res = new Mat(count, 1, CvType.CV_64FC2);\r
- double[] buff = new double[count*2];\r
- for(int i=0; i<count; i++) {\r
- Point p = pts.get(i);\r
- buff[i*2] = p.x;\r
- buff[i*2+1] = p.y;\r
- }\r
- res.put(0, 0, buff);\r
+ case CvType.CV_64F: {\r
+ res = new Mat(count, 1, CvType.CV_64FC2);\r
+ double[] buff = new double[count * 2];\r
+ for (int i = 0; i < count; i++) {\r
+ Point p = pts.get(i);\r
+ buff[i * 2] = p.x;\r
+ buff[i * 2 + 1] = p.y;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- default:\r
- throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");\r
+ default:\r
+ throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");\r
}\r
} else {\r
res = new Mat();\r
return res;\r
}\r
\r
-\r
public static Mat vector_Point3i_to_Mat(List<Point3> pts) {\r
return vector_Point3_to_Mat(pts, CvType.CV_32S);\r
}\r
\r
public static Mat vector_Point3_to_Mat(List<Point3> pts, int typeDepth) {\r
Mat res;\r
- int count = (pts!=null) ? pts.size() : 0;\r
- if(count>0){\r
- switch (typeDepth){\r
- case CvType.CV_32S:\r
- {\r
- res = new Mat(count, 1, CvType.CV_32SC3);\r
- int[] buff = new int[count*3];\r
- for(int i=0; i<count; i++) {\r
- Point3 p = pts.get(i);\r
- buff[i*3] = (int)p.x;\r
- buff[i*3+1] = (int)p.y;\r
- buff[i*3+2] = (int)p.z;\r
- }\r
- res.put(0, 0, buff);\r
+ int count = (pts != null) ? pts.size() : 0;\r
+ if (count > 0) {\r
+ switch (typeDepth) {\r
+ case CvType.CV_32S: {\r
+ res = new Mat(count, 1, CvType.CV_32SC3);\r
+ int[] buff = new int[count * 3];\r
+ for (int i = 0; i < count; i++) {\r
+ Point3 p = pts.get(i);\r
+ buff[i * 3] = (int) p.x;\r
+ buff[i * 3 + 1] = (int) p.y;\r
+ buff[i * 3 + 2] = (int) p.z;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- case CvType.CV_32F:\r
- {\r
- res = new Mat(count, 1, CvType.CV_32FC3);\r
- float[] buff = new float[count*3];\r
- for(int i=0; i<count; i++) {\r
- Point3 p = pts.get(i);\r
- buff[i*3] = (float)p.x;\r
- buff[i*3+1] = (float)p.y;\r
- buff[i*3+2] = (float)p.z;\r
- }\r
- res.put(0, 0, buff);\r
+ case CvType.CV_32F: {\r
+ res = new Mat(count, 1, CvType.CV_32FC3);\r
+ float[] buff = new float[count * 3];\r
+ for (int i = 0; i < count; i++) {\r
+ Point3 p = pts.get(i);\r
+ buff[i * 3] = (float) p.x;\r
+ buff[i * 3 + 1] = (float) p.y;\r
+ buff[i * 3 + 2] = (float) p.z;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- case CvType.CV_64F:\r
- {\r
- res = new Mat(count, 1, CvType.CV_64FC3);\r
- double[] buff = new double[count*3];\r
- for(int i=0; i<count; i++) {\r
- Point3 p = pts.get(i);\r
- buff[i*3] = p.x;\r
- buff[i*3+1] = p.y;\r
- buff[i*3+2] = p.z;\r
- }\r
- res.put(0, 0, buff);\r
+ case CvType.CV_64F: {\r
+ res = new Mat(count, 1, CvType.CV_64FC3);\r
+ double[] buff = new double[count * 3];\r
+ for (int i = 0; i < count; i++) {\r
+ Point3 p = pts.get(i);\r
+ buff[i * 3] = p.x;\r
+ buff[i * 3 + 1] = p.y;\r
+ buff[i * 3 + 2] = p.z;\r
}\r
+ res.put(0, 0, buff);\r
+ }\r
break;\r
\r
- default:\r
- throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");\r
+ default:\r
+ throw new IllegalArgumentException("'typeDepth' can be CV_32S, CV_32F or CV_64F");\r
}\r
} else {\r
res = new Mat();\r
public static void Mat_to_vector_Point2d(Mat m, List<Point> pts) {\r
Mat_to_vector_Point(m, pts);\r
}\r
+\r
public static void Mat_to_vector_Point(Mat m, List<Point> pts) {\r
- if(pts == null)\r
+ if (pts == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
int type = m.type();\r
- if(m.cols() != 1)\r
- throw new java.lang.IllegalArgumentException( "Input Mat should have one column\n" + m );\r
+ if (m.cols() != 1)\r
+ throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);\r
\r
pts.clear();\r
- if(type == CvType.CV_32SC2) {\r
- int[] buff = new int[2*count];\r
+ if (type == CvType.CV_32SC2) {\r
+ int[] buff = new int[2 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point(buff[i*2], buff[i*2+1]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));\r
}\r
- } else if(type == CvType.CV_32FC2){\r
- float[] buff = new float[2*count];\r
+ } else if (type == CvType.CV_32FC2) {\r
+ float[] buff = new float[2 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point(buff[i*2], buff[i*2+1]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));\r
}\r
- } else if(type == CvType.CV_64FC2){\r
- double[] buff = new double[2*count];\r
+ } else if (type == CvType.CV_64FC2) {\r
+ double[] buff = new double[2 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point(buff[i*2], buff[i*2+1]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point(buff[i * 2], buff[i * 2 + 1]));\r
}\r
} else {\r
throw new java.lang.IllegalArgumentException(\r
- "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m );\r
+ "Input Mat should be of CV_32SC2, CV_32FC2 or CV_64FC2 type\n" + m);\r
}\r
}\r
\r
public static void Mat_to_vector_Point3i(Mat m, List<Point3> pts) {\r
Mat_to_vector_Point3(m, pts);\r
}\r
+\r
public static void Mat_to_vector_Point3f(Mat m, List<Point3> pts) {\r
Mat_to_vector_Point3(m, pts);\r
}\r
public static void Mat_to_vector_Point3d(Mat m, List<Point3> pts) {\r
Mat_to_vector_Point3(m, pts);\r
}\r
+\r
public static void Mat_to_vector_Point3(Mat m, List<Point3> pts) {\r
- if(pts == null)\r
+ if (pts == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
int type = m.type();\r
- if(m.cols() != 1)\r
- throw new java.lang.IllegalArgumentException( "Input Mat should have one column\n" + m );\r
+ if (m.cols() != 1)\r
+ throw new java.lang.IllegalArgumentException("Input Mat should have one column\n" + m);\r
\r
pts.clear();\r
- if(type == CvType.CV_32SC3) {\r
- int[] buff = new int[3*count];\r
+ if (type == CvType.CV_32SC3) {\r
+ int[] buff = new int[3 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point3(buff[i*3], buff[i*3+1], buff[i*3+2]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));\r
}\r
- } else if(type == CvType.CV_32FC3){\r
- float[] buff = new float[3*count];\r
+ } else if (type == CvType.CV_32FC3) {\r
+ float[] buff = new float[3 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point3(buff[i*3], buff[i*3+1], buff[i*3+2]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));\r
}\r
- } else if(type == CvType.CV_64FC3){\r
- double[] buff = new double[3*count];\r
+ } else if (type == CvType.CV_64FC3) {\r
+ double[] buff = new double[3 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- pts.add( new Point3(buff[i*3], buff[i*3+1], buff[i*3+2]) );\r
+ for (int i = 0; i < count; i++) {\r
+ pts.add(new Point3(buff[i * 3], buff[i * 3 + 1], buff[i * 3 + 2]));\r
}\r
} else {\r
throw new java.lang.IllegalArgumentException(\r
- "Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m );\r
+ "Input Mat should be of CV_32SC3, CV_32FC3 or CV_64FC3 type\n" + m);\r
}\r
}\r
\r
public static Mat vector_Mat_to_Mat(List<Mat> mats) {\r
Mat res;\r
- int count = (mats!=null) ? mats.size() : 0;\r
- if(count>0){\r
+ int count = (mats != null) ? mats.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_32SC2);\r
- int[] buff = new int[count*2];\r
- for(int i=0; i<count; i++) {\r
+ int[] buff = new int[count * 2];\r
+ for (int i = 0; i < count; i++) {\r
long addr = mats.get(i).nativeObj;\r
- buff[i*2] = (int)(addr >> 32);\r
- buff[i*2+1] = (int)(addr & 0xffffffff);\r
+ buff[i * 2] = (int) (addr >> 32);\r
+ buff[i * 2 + 1] = (int) (addr & 0xffffffff);\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_Mat(Mat m, List<Mat> mats) {\r
- if(mats == null)\r
+ if (mats == null)\r
throw new java.lang.IllegalArgumentException("mats == null");\r
int count = m.rows();\r
- if( CvType.CV_32SC2 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_32SC2 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_32SC2 != m.type() || m.cols()!=1\n" + m);\r
\r
mats.clear();\r
- int[] buff = new int[count*2];\r
+ int[] buff = new int[count * 2];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- long addr = (((long)buff[i*2])<<32) | ((long)buff[i*2+1]);\r
- mats.add( new Mat(addr) );\r
+ for (int i = 0; i < count; i++) {\r
+ long addr = (((long) buff[i * 2]) << 32) | ((long) buff[i * 2 + 1]);\r
+ mats.add(new Mat(addr));\r
}\r
}\r
\r
public static Mat vector_float_to_Mat(List<Float> fs) {\r
Mat res;\r
- int count = (fs!=null) ? fs.size() : 0;\r
- if(count>0){\r
+ int count = (fs != null) ? fs.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_32FC1);\r
float[] buff = new float[count];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
float f = fs.get(i);\r
- buff[i] = f;\r
+ buff[i] = f;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_float(Mat m, List<Float> fs) {\r
- if(fs == null)\r
+ if (fs == null)\r
throw new java.lang.IllegalArgumentException("fs == null");\r
int count = m.rows();\r
- if( CvType.CV_32FC1 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_32FC1 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_32FC1 != m.type() || m.cols()!=1\n" + m);\r
\r
fs.clear();\r
float[] buff = new float[count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- fs.add( buff[i] );\r
+ for (int i = 0; i < count; i++) {\r
+ fs.add(buff[i]);\r
}\r
}\r
\r
public static Mat vector_uchar_to_Mat(List<Byte> bs) {\r
Mat res;\r
- int count = (bs!=null) ? bs.size() : 0;\r
- if(count>0){\r
+ int count = (bs != null) ? bs.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_8UC1);\r
byte[] buff = new byte[count];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
byte b = bs.get(i);\r
- buff[i] = b;\r
+ buff[i] = b;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_uchar(Mat m, List<Byte> us) {\r
- if(us == null)\r
+ if (us == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
- if( CvType.CV_8UC1 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_8UC1 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_8UC1 != m.type() || m.cols()!=1\n" + m);\r
\r
us.clear();\r
byte[] buff = new byte[count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- us.add( buff[i] );\r
+ for (int i = 0; i < count; i++) {\r
+ us.add(buff[i]);\r
}\r
}\r
\r
-\r
public static Mat vector_char_to_Mat(List<Byte> bs) {\r
Mat res;\r
- int count = (bs!=null) ? bs.size() : 0;\r
- if(count>0){\r
+ int count = (bs != null) ? bs.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_8SC1);\r
byte[] buff = new byte[count];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
byte b = bs.get(i);\r
- buff[i] = b;\r
+ buff[i] = b;\r
}\r
res.put(0, 0, buff);\r
} else {\r
\r
public static Mat vector_int_to_Mat(List<Integer> is) {\r
Mat res;\r
- int count = (is!=null) ? is.size() : 0;\r
- if(count>0){\r
+ int count = (is != null) ? is.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_32SC1);\r
int[] buff = new int[count];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
int v = is.get(i);\r
- buff[i] = v;\r
+ buff[i] = v;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_int(Mat m, List<Integer> is) {\r
- if(is == null)\r
+ if (is == null)\r
throw new java.lang.IllegalArgumentException("is == null");\r
int count = m.rows();\r
- if( CvType.CV_32SC1 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_32SC1 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_32SC1 != m.type() || m.cols()!=1\n" + m);\r
\r
is.clear();\r
int[] buff = new int[count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- is.add( buff[i] );\r
+ for (int i = 0; i < count; i++) {\r
+ is.add(buff[i]);\r
}\r
}\r
\r
public static void Mat_to_vector_char(Mat m, List<Byte> bs) {\r
- if(bs == null)\r
+ if (bs == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
- if( CvType.CV_8SC1 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_8SC1 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_8SC1 != m.type() || m.cols()!=1\n" + m);\r
\r
bs.clear();\r
byte[] buff = new byte[count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- bs.add( buff[i] );\r
+ for (int i = 0; i < count; i++) {\r
+ bs.add(buff[i]);\r
}\r
}\r
\r
public static Mat vector_Rect_to_Mat(List<Rect> rs) {\r
Mat res;\r
- int count = (rs!=null) ? rs.size() : 0;\r
- if(count>0){\r
+ int count = (rs != null) ? rs.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_32SC4);\r
- int[] buff = new int[4*count];\r
- for(int i=0; i<count; i++) {\r
+ int[] buff = new int[4 * count];\r
+ for (int i = 0; i < count; i++) {\r
Rect r = rs.get(i);\r
- buff[4*i ] = r.x;\r
- buff[4*i+1] = r.y;\r
- buff[4*i+2] = r.width;\r
- buff[4*i+3] = r.height;\r
+ buff[4 * i] = r.x;\r
+ buff[4 * i + 1] = r.y;\r
+ buff[4 * i + 2] = r.width;\r
+ buff[4 * i + 3] = r.height;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_Rect(Mat m, List<Rect> rs) {\r
- if(rs == null)\r
+ if (rs == null)\r
throw new java.lang.IllegalArgumentException("rs == null");\r
int count = m.rows();\r
- if(CvType.CV_32SC4 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_32SC4 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_32SC4 != m.type() || m.rows()!=1\n" + m);\r
\r
rs.clear();\r
- int[] buff = new int[4*count];\r
+ int[] buff = new int[4 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- rs.add( new Rect(buff[4*i], buff[4*i+1], buff[4*i+2], buff[4*i+3]) );\r
+ for (int i = 0; i < count; i++) {\r
+ rs.add(new Rect(buff[4 * i], buff[4 * i + 1], buff[4 * i + 2], buff[4 * i + 3]));\r
}\r
}\r
\r
-\r
public static Mat vector_KeyPoint_to_Mat(List<KeyPoint> kps) {\r
Mat res;\r
- int count = (kps!=null) ? kps.size() : 0;\r
- if(count>0){\r
+ int count = (kps != null) ? kps.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_64FC(7));\r
double[] buff = new double[count * 7];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
KeyPoint kp = kps.get(i);\r
- buff[7*i ] = kp.pt.x;\r
- buff[7*i+1] = kp.pt.y;\r
- buff[7*i+2] = kp.size;\r
- buff[7*i+3] = kp.angle;\r
- buff[7*i+4] = kp.response;\r
- buff[7*i+5] = kp.octave;\r
- buff[7*i+6] = kp.class_id;\r
+ buff[7 * i] = kp.pt.x;\r
+ buff[7 * i + 1] = kp.pt.y;\r
+ buff[7 * i + 2] = kp.size;\r
+ buff[7 * i + 3] = kp.angle;\r
+ buff[7 * i + 4] = kp.response;\r
+ buff[7 * i + 5] = kp.octave;\r
+ buff[7 * i + 6] = kp.class_id;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_KeyPoint(Mat m, List<KeyPoint> kps) {\r
- if(kps == null)\r
+ if (kps == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
- if( CvType.CV_64FC(7) != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_64FC(7) != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_64FC(7) != m.type() || m.cols()!=1\n" + m);\r
\r
kps.clear();\r
- double[] buff = new double[7*count];\r
+ double[] buff = new double[7 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- kps.add( new KeyPoint( (float)buff[7*i], (float)buff[7*i+1], (float)buff[7*i+2], (float)buff[7*i+3],\r
- (float)buff[7*i+4], (int)buff[7*i+5], (int)buff[7*i+6] ) );\r
+ for (int i = 0; i < count; i++) {\r
+ kps.add(new KeyPoint((float) buff[7 * i], (float) buff[7 * i + 1], (float) buff[7 * i + 2], (float) buff[7 * i + 3],\r
+ (float) buff[7 * i + 4], (int) buff[7 * i + 5], (int) buff[7 * i + 6]));\r
}\r
}\r
+ \r
+ // vector_vector_Point\r
+ public static Mat vector_vector_Point_to_Mat(List<List<Point>> pts) {\r
+ Mat res;\r
+ int lCount = (pts != null) ? pts.size() : 0;\r
+ if (lCount > 0) {\r
+ List<Mat> mats = new ArrayList<Mat>(lCount);\r
+ for (List<Point> lpt : pts)\r
+ mats.add(vector_Point_to_Mat(lpt));\r
+ res = vector_Mat_to_Mat(mats);\r
+ } else {\r
+ res = new Mat();\r
+ }\r
+ return res;\r
+ }\r
\r
// vector_vector_KeyPoint\r
public static Mat vector_vector_KeyPoint_to_Mat(List<List<KeyPoint>> kps) {\r
Mat res;\r
- int lCount = (kps!=null) ? kps.size() : 0;\r
- if(lCount>0){\r
+ int lCount = (kps != null) ? kps.size() : 0;\r
+ if (lCount > 0) {\r
List<Mat> mats = new ArrayList<Mat>(lCount);\r
- for(List<KeyPoint> lkp: kps) mats.add( vector_KeyPoint_to_Mat(lkp) );\r
+ for (List<KeyPoint> lkp : kps)\r
+ mats.add(vector_KeyPoint_to_Mat(lkp));\r
res = vector_Mat_to_Mat(mats);\r
} else {\r
res = new Mat();\r
}\r
\r
public static void Mat_to_vector_vector_KeyPoint(Mat m, List<List<KeyPoint>> kps) {\r
- if(kps == null)\r
+ if (kps == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
\r
- if(m == null)\r
+ if (m == null)\r
throw new java.lang.IllegalArgumentException("Input Mat can't be null");\r
\r
List<Mat> mats = new ArrayList<Mat>(m.rows());\r
Mat_to_vector_Mat(m, mats);\r
List<KeyPoint> lkp = new ArrayList<KeyPoint>();\r
- for(Mat mi : mats) {\r
+ for (Mat mi : mats) {\r
Mat_to_vector_KeyPoint(mi, lkp);\r
kps.add(lkp);\r
}\r
}\r
\r
-\r
public static Mat vector_double_to_Mat(List<Double> ds) {\r
Mat res;\r
- int count = (ds!=null) ? ds.size() : 0;\r
- if(count>0){\r
+ int count = (ds != null) ? ds.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_64FC1);\r
double[] buff = new double[count];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
double v = ds.get(i);\r
- buff[i] = v;\r
+ buff[i] = v;\r
}\r
res.put(0, 0, buff);\r
} else {\r
\r
public static Mat vector_DMatch_to_Mat(List<DMatch> matches) {\r
Mat res;\r
- int count = (matches!=null) ? matches.size() : 0;\r
- if(count>0){\r
+ int count = (matches != null) ? matches.size() : 0;\r
+ if (count > 0) {\r
res = new Mat(count, 1, CvType.CV_64FC4);\r
double[] buff = new double[count * 4];\r
- for(int i=0; i<count; i++) {\r
+ for (int i = 0; i < count; i++) {\r
DMatch m = matches.get(i);\r
- buff[4*i ] = m.queryIdx;\r
- buff[4*i+1] = m.trainIdx;\r
- buff[4*i+2] = m.imgIdx;\r
- buff[4*i+3] = m.distance;\r
+ buff[4 * i] = m.queryIdx;\r
+ buff[4 * i + 1] = m.trainIdx;\r
+ buff[4 * i + 2] = m.imgIdx;\r
+ buff[4 * i + 3] = m.distance;\r
}\r
res.put(0, 0, buff);\r
} else {\r
}\r
\r
public static void Mat_to_vector_DMatch(Mat m, List<DMatch> matches) {\r
- if(matches == null)\r
+ if (matches == null)\r
throw new java.lang.IllegalArgumentException("Output List can't be null");\r
int count = m.rows();\r
- if( CvType.CV_64FC4 != m.type() || m.cols()!=1 )\r
+ if (CvType.CV_64FC4 != m.type() || m.cols() != 1)\r
throw new java.lang.IllegalArgumentException(\r
"CvType.CV_64FC4 != m.type() || m.cols()!=1\n" + m);\r
\r
matches.clear();\r
- double[] buff = new double[4*count];\r
+ double[] buff = new double[4 * count];\r
m.get(0, 0, buff);\r
- for(int i=0; i<count; i++) {\r
- matches.add( new DMatch( (int)buff[4*i], (int)buff[4*i+1], (int)buff[4*i+2], (float)buff[4*i+3] ) );\r
+ for (int i = 0; i < count; i++) {\r
+ matches.add(new DMatch((int) buff[4 * i], (int) buff[4 * i + 1], (int) buff[4 * i + 2], (float) buff[4 * i + 3]));\r
}\r
}\r
\r
-\r
-// vector_vector_DMatch\r
-public static Mat vector_vector_DMatch_to_Mat(List<List<DMatch>> lldm) {\r
- Mat res;\r
- int lCount = (lldm!=null) ? lldm.size() : 0;\r
- if(lCount>0){\r
- List<Mat> mats = new ArrayList<Mat>(lCount);\r
- for(List<DMatch> ldm: lldm) mats.add( vector_DMatch_to_Mat(ldm) );\r
- res = vector_Mat_to_Mat(mats);\r
- } else {\r
- res = new Mat();\r
+ // vector_vector_DMatch\r
+ public static Mat vector_vector_DMatch_to_Mat(List<List<DMatch>> lldm) {\r
+ Mat res;\r
+ int lCount = (lldm != null) ? lldm.size() : 0;\r
+ if (lCount > 0) {\r
+ List<Mat> mats = new ArrayList<Mat>(lCount);\r
+ for (List<DMatch> ldm : lldm)\r
+ mats.add(vector_DMatch_to_Mat(ldm));\r
+ res = vector_Mat_to_Mat(mats);\r
+ } else {\r
+ res = new Mat();\r
+ }\r
+ return res;\r
}\r
- return res;\r
-}\r
\r
-public static void Mat_to_vector_vector_DMatch(Mat m, List<List<DMatch>> lldm) {\r
- if(lldm == null)\r
- throw new java.lang.IllegalArgumentException("Output List can't be null");\r
+ public static void Mat_to_vector_vector_DMatch(Mat m, List<List<DMatch>> lldm) {\r
+ if (lldm == null)\r
+ throw new java.lang.IllegalArgumentException("Output List can't be null");\r
\r
- if(m == null)\r
- throw new java.lang.IllegalArgumentException("Input Mat can't be null");\r
+ if (m == null)\r
+ throw new java.lang.IllegalArgumentException("Input Mat can't be null");\r
\r
- List<Mat> mats = new ArrayList<Mat>(m.rows());\r
- Mat_to_vector_Mat(m, mats);\r
- List<DMatch> ldm = new ArrayList<DMatch>();\r
- for(Mat mi : mats) {\r
- Mat_to_vector_DMatch(mi, ldm);\r
- lldm.add(ldm);\r
+ List<Mat> mats = new ArrayList<Mat>(m.rows());\r
+ Mat_to_vector_Mat(m, mats);\r
+ List<DMatch> ldm = new ArrayList<DMatch>();\r
+ for (Mat mi : mats) {\r
+ Mat_to_vector_DMatch(mi, ldm);\r
+ lldm.add(ldm);\r
+ }\r
}\r
-}\r
\r
-//vector_vector_char\r
-public static Mat vector_vector_char_to_Mat(List<List<Byte>> llb) {\r
- Mat res;\r
- int lCount = (llb!=null) ? llb.size() : 0;\r
- if(lCount>0){\r
- List<Mat> mats = new ArrayList<Mat>(lCount);\r
- for(List<Byte> lb: llb) mats.add( vector_char_to_Mat(lb) );\r
- res = vector_Mat_to_Mat(mats);\r
- } else {\r
- res = new Mat();\r
- }\r
- return res;\r
-}\r
+ // vector_vector_char\r
+ public static Mat vector_vector_char_to_Mat(List<List<Byte>> llb) {\r
+ Mat res;\r
+ int lCount = (llb != null) ? llb.size() : 0;\r
+ if (lCount > 0) {\r
+ List<Mat> mats = new ArrayList<Mat>(lCount);\r
+ for (List<Byte> lb : llb)\r
+ mats.add(vector_char_to_Mat(lb));\r
+ res = vector_Mat_to_Mat(mats);\r
+ } else {\r
+ res = new Mat();\r
+ }\r
+ return res;\r
+ }\r
\r
-public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) {\r
- if(llb == null)\r
- throw new java.lang.IllegalArgumentException("Output List can't be null");\r
+ public static void Mat_to_vector_vector_char(Mat m, List<List<Byte>> llb) {\r
+ if (llb == null)\r
+ throw new java.lang.IllegalArgumentException("Output List can't be null");\r
\r
- if(m == null)\r
- throw new java.lang.IllegalArgumentException("Input Mat can't be null");\r
+ if (m == null)\r
+ throw new java.lang.IllegalArgumentException("Input Mat can't be null");\r
\r
- List<Mat> mats = new ArrayList<Mat>(m.rows());\r
- Mat_to_vector_Mat(m, mats);\r
- List<Byte> lb = new ArrayList<Byte>();\r
- for(Mat mi : mats) {\r
- Mat_to_vector_char(mi, lb);\r
- llb.add(lb);\r
- }\r
-}\r
+ List<Mat> mats = new ArrayList<Mat>(m.rows());\r
+ Mat_to_vector_Mat(m, mats);\r
+ List<Byte> lb = new ArrayList<Byte>();\r
+ for (Mat mi : mats) {\r
+ Mat_to_vector_char(mi, lb);\r
+ llb.add(lb);\r
+ }\r
+ }\r
\r
}\r
projects / profile / ivi / opencv.git / commitdiff