public void testAbsdiff() {

Core.absdiff(gray128, gray255, dst);

assertMatEqual(gray127, dst);

}

public void testAddMatMatMat() {

Core.add(gray128, gray128, dst);

assertMatEqual(gray255, dst);

}

public void testAddMatMatMatMatInt() {

Core.add(gray0, gray1, dst, gray1, CvType.CV_32F);

assertEquals(CvType.CV_32F, dst.depth());

assertMatEqual(gray1_32f, dst, EPS);

}

public void testAddWeightedMatDoubleMatDoubleDoubleMat() {

Core.addWeighted(gray1, 120.0, gray127, 1.0, 10.0, dst);

assertMatEqual(gray255, dst);

}

public void testAddWeightedMatDoubleMatDoubleDoubleMatInt() {

Core.addWeighted(gray1, 126.0, gray127, 1.0, 2.0, dst, CvType.CV_32F);

assertEquals(CvType.CV_32F, dst.depth());

assertMatEqual(gray255_32f, dst, EPS);

}

public void testBitwise_andMatMatMat() {

Core.bitwise_and(gray127, gray3, dst);

assertMatEqual(gray3, dst);

}

public void testBitwise_andMatMatMatMat() {

Core.bitwise_and(gray3, gray1, dst, gray255);

assertMatEqual(gray1, dst);

}

public void testBitwise_notMatMat() {

Core.bitwise_not(gray255, dst);

assertMatEqual(gray0, dst);

}

public void testBitwise_notMatMatMat() {

Core.bitwise_not(gray0, dst, gray1);

assertMatEqual(gray255, dst);

}

public void testBitwise_orMatMatMat() {

Core.bitwise_or(gray1, gray2, dst);

assertMatEqual(gray3, dst);

}

public void testBitwise_orMatMatMatMat() {

Core.bitwise_or(gray127, gray3, dst, gray255);

assertMatEqual(gray127, dst);

}

public void testBitwise_xorMatMatMat() {

Core.bitwise_xor(gray3, gray2, dst);

assertMatEqual(gray1, dst);

}

public void testBitwise_xorMatMatMatMat() {

Core.bitwise_or(gray127, gray128, dst, gray255);

assertMatEqual(gray255, dst);

}

public void testCalcCovarMatrixMatMatMatInt() {

Mat covar = new Mat(matSize, matSize, CvType.CV_64FC1);

Mat mean = new Mat(1, matSize, CvType.CV_64FC1);

Core.calcCovarMatrix(gray0_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL);

assertMatEqual(gray0_64f, covar, EPS);

assertMatEqual(gray0_64f_1d, mean, EPS);

}

public void testCalcCovarMatrixMatMatMatIntInt() {

Mat covar = new Mat(matSize, matSize, CvType.CV_32F);

Mat mean = new Mat(1, matSize, CvType.CV_32F);

Core.calcCovarMatrix(gray0_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL, CvType.CV_32F);

assertMatEqual(gray0_32f, covar, EPS);

assertMatEqual(gray0_32f_1d, mean, EPS);

}

public void testCartToPolarMatMatMatMat() {

Mat x = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 3.0, 6.0, 5, 0);

}

};

Mat y = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 4.0, 8.0, 12.0);

}

};

Mat dst_angle = new Mat();

Core.cartToPolar(x, y, dst, dst_angle);

Mat expected_magnitude = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 5.0, 10.0, 13.0);

}

};

Mat expected_angle = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, atan2rad(4,3), atan2rad(8,6), atan2rad(12,5));

}

};

assertMatEqual(expected_magnitude, dst, EPS);

assertMatEqual(expected_angle, dst_angle, EPS);

}

public void testCartToPolarMatMatMatMatBoolean() {

Mat x = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 3.0, 6.0, 5, 0);

}

};

Mat y = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 4.0, 8.0, 12.0);

}

};

Mat dst_angle = new Mat();

Core.cartToPolar(x, y, dst, dst_angle, true);

Mat expected_magnitude = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, 5.0, 10.0, 13.0);

}

};

Mat expected_angle = new Mat(1, 3, CvType.CV_32F) {

{

put(0, 0, atan2deg(4,3), atan2deg(8,6), atan2deg(12,5));

}

};

assertMatEqual(expected_magnitude, dst, EPS);

assertMatEqual(expected_angle, dst_angle, EPS * 180/Math.PI);

}

public void testCheckRangeMat() {

Mat outOfRange = new Mat(2, 2, CvType.CV_64F);

outOfRange.put(0, 0, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0);

assertTrue(Core.checkRange(grayRnd_32f));

assertTrue(Core.checkRange(new Mat()));

assertFalse(Core.checkRange(outOfRange));

}

public void testCheckRangeMatBooleanPointDoubleDouble() {

Mat inRange = new Mat(2, 3, CvType.CV_64F) {

{

put(0, 0, 14, 48, 76, 33, 5, 99);

}

};

assertTrue(Core.checkRange(inRange, true, 5, 100));

Mat outOfRange = new Mat(2, 3, CvType.CV_64F) {

{

put(0, 0, -4, 0, 6, 33, 4, 109);

}

};

assertFalse(Core.checkRange(outOfRange, true, 5, 100));

}

public void testCompare() {

Core.compare(gray0, gray0, dst, Core.CMP_EQ);

assertMatEqual(dst, gray255);

Core.compare(gray0, gray1, dst, Core.CMP_EQ);

assertMatEqual(dst, gray0);

grayRnd.put(0, 0, 0, 0);

Core.compare(gray0, grayRnd, dst, Core.CMP_GE);

int expected = (int) (grayRnd.total() - Core.countNonZero(grayRnd));

assertEquals(expected, Core.countNonZero(dst));

}

public void testCompleteSymmMat() {

Core.completeSymm(grayRnd_32f);

assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);

}

public void testCompleteSymmMatBoolean() {

Mat grayRnd_32f2 = grayRnd_32f.clone();

Core.completeSymm(grayRnd_32f, true);

assertMatEqual(grayRnd_32f, grayRnd_32f.t(), EPS);

Core.completeSymm(grayRnd_32f2, false);

assertMatNotEqual(grayRnd_32f2, grayRnd_32f, EPS);

}

public void testConvertScaleAbsMatMat() {

Core.convertScaleAbs(gray0, dst);

assertMatEqual(gray0, dst, EPS);

Core.convertScaleAbs(gray_16u_256, dst);

assertMatEqual(gray255, dst, EPS);

}

public void testConvertScaleAbsMatMatDoubleDouble() {

Core.convertScaleAbs(gray_16u_256, dst, 2, -513);

assertMatEqual(gray1, dst);

}

public void testCountNonZero() {

assertEquals(0, Core.countNonZero(gray0));

gray0.put(0, 0, 255);

gray0.put(gray0.rows() - 1, gray0.cols() - 1, 255);

assertEquals(2, Core.countNonZero(gray0));

}

public void testCubeRoot() {

float res = Core.cubeRoot(-27.0f);

assertEquals(-3.0f, res);

}

public void testDctMatMat() {

Mat in = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 135.22211, 50.811096, 102.27016, 207.6682);

}

};

Mat dst1 = new Mat();

Mat dst2 = new Mat();

Core.dct(gray0_32f_1d, dst1);

Core.dct(in, dst2);

truth = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 247.98576, -61.252407, 94.904533, 14.013477);

}

};

assertMatEqual(gray0_32f_1d, dst1, EPS);

assertMatEqual(truth, dst2, EPS);

}

public void testDctMatMatInt() {

Mat in = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 247.98576, -61.252407, 94.904533, 14.013477);

}

};

Mat dst1 = new Mat();

Mat dst2 = new Mat();

Core.dct(gray0_32f_1d, dst1, Core.DCT_INVERSE);

Core.dct(in, dst2, Core.DCT_INVERSE);

truth = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 135.22211, 50.811096, 102.27016, 207.6682);

}

};

assertMatEqual(gray0_32f_1d, dst1, EPS);

assertMatEqual(truth, dst2, EPS);

}

public void testDeterminant() {

Mat mat = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 4.0);

put(0, 1, 2.0);

put(1, 0, 4.0);

put(1, 1, 4.0);

}

};

double det = Core.determinant(mat);

assertEquals(8.0, det);

}

public void testDftMatMat() {

Core.dft(gray0_32f_1d, dst);

assertMatEqual(gray0_32f_1d, dst, EPS);

}

public void testDftMatMatIntInt() {

Mat src1 = new Mat(2, 4, CvType.CV_32F) {

{

put(0, 0, 1, 2, 3, 4);

put(1, 0, 1, 1, 1, 1);

}

};

Mat src2 = new Mat(2, 4, CvType.CV_32F) {

{

put(0, 0, 1, 2, 3, 4);

put(1, 0, 0, 0, 0, 0);

}

};

Mat dst1 = new Mat();

Mat dst2 = new Mat();

Core.dft(src1, dst1, Core.DFT_REAL_OUTPUT, 1);

Core.dft(src2, dst2, Core.DFT_REAL_OUTPUT, 0);

assertMatEqual(dst2, dst1, EPS);

}

public void testDivideDoubleMatMat() {

Core.divide(4.0, gray2, dst);

assertMatEqual(gray2, dst);

Core.divide(4.0, gray0, dst);

assertMatEqual(gray0, dst);

}

public void testDivideDoubleMatMatInt() {

Core.divide(9.0, gray3, dst, CvType.CV_32F);

assertMatEqual(gray3_32f, dst, EPS);

}

public void testDivideMatMatMat() {

Core.divide(gray9, gray3, dst);

assertMatEqual(gray3, dst);

}

public void testDivideMatMatMatDouble() {

Core.divide(gray1, gray2, dst, 6.0);

assertMatEqual(gray3, dst);

}

public void testDivideMatMatMatDoubleInt() {

Core.divide(gray1, gray2, dst, 6.0, CvType.CV_32F);

assertMatEqual(gray3_32f, dst, EPS);

}

public void testEigen() {

Mat src = new Mat(3, 3, CvType.CV_32FC1) {

{

put(0, 0, 2, 0, 0);

put(1, 0, 0, 6, 0);

put(2, 0, 0, 0, 4);

}

};

Mat eigenVals = new Mat();

Mat eigenVecs = new Mat();

Core.eigen(src, eigenVals, eigenVecs);

Mat expectedEigenVals = new Mat(3, 1, CvType.CV_32FC1) {

{

put(0, 0, 6, 4, 2);

}

};

assertMatEqual(eigenVals, expectedEigenVals, EPS);

// check by definition

double eps = 1e-3;

for(int i = 0; i < 3; i++)

{

Mat vec = eigenVecs.row(i).t();

Mat lhs = new Mat(3, 1, CvType.CV_32FC1);

Core.gemm(src, vec, 1.0, new Mat(), 1.0, lhs);

Mat rhs = new Mat(3, 1, CvType.CV_32FC1);

Core.gemm(vec, eigenVals.row(i), 1.0, new Mat(), 1.0, rhs);

assertMatEqual(lhs, rhs, eps);

}

}

public void testExp() {

Core.exp(gray0_32f, dst);

assertMatEqual(gray1_32f, dst, EPS);

}

public void testExtractChannel() {

Core.extractChannel(rgba128, dst, 0);

assertMatEqual(gray128, dst);

}

public void testFastAtan2() {

double eps = 0.3;

float res = Core.fastAtan2(50, 50);

assertEquals(45, res, eps);

float res2 = Core.fastAtan2(80, 20);

assertEquals(Math.atan2(80, 20) * 180 / Math.PI, res2, eps);

}

public void testFillConvexPolyMatListOfPointScalar() {

MatOfPoint polyline = new MatOfPoint(new Point[]{new Point(1, 1), new Point(5, 0), new Point(6, 8), new Point(0, 9)});

Imgproc.fillConvexPoly(gray0, polyline, new Scalar(150));

assertTrue(0 < Core.countNonZero(gray0));

assertTrue(gray0.total() > Core.countNonZero(gray0));

}

public void testFillConvexPolyMatListOfPointScalarIntInt() {

MatOfPoint polyline1 = new MatOfPoint(new Point(2, 1), new Point(5, 1), new Point(5, 7), new Point(2, 7));

MatOfPoint polyline2 = new MatOfPoint(new Point(4, 2), new Point(10, 2), new Point(10, 14), new Point(4, 14));

// current implementation of fixed-point version of fillConvexPoly

// requires image to be at least 2-pixel wider in each direction than

// contour

Imgproc.fillConvexPoly(gray0, polyline1, colorWhite, Imgproc.LINE_8, 0);

assertTrue(0 < Core.countNonZero(gray0));

assertTrue(gray0.total() > Core.countNonZero(gray0));

Imgproc.fillConvexPoly(gray0, polyline2, colorBlack, Imgproc.LINE_8, 1);

assertEquals("see http://code.opencv.org/issues/1284", 0, Core.countNonZero(gray0));

}

public void testFillPolyMatListOfListOfPointScalar() {

int matSize = 10;

Mat gray0 = Mat.zeros(matSize, matSize, CvType.CV_8U);

MatOfPoint polyline = new MatOfPoint(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(7, 4));

List<MatOfPoint> polylines = new ArrayList<MatOfPoint>();

polylines.add(polyline);

Imgproc.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 testFillPolyMatListOfListOfPointScalarIntIntPoint() {

MatOfPoint polyline1 = new MatOfPoint(new Point(1, 4), new Point(1, 8), new Point(4, 1), new Point(7, 8), new Point(7, 4));

MatOfPoint polyline2 = new MatOfPoint(new Point(0, 3), new Point(0, 7), new Point(3, 0), new Point(6, 7), new Point(6, 3));

List<MatOfPoint> polylines1 = new ArrayList<MatOfPoint>();

polylines1.add(polyline1);

List<MatOfPoint> polylines2 = new ArrayList<MatOfPoint>();

polylines2.add(polyline2);

Imgproc.fillPoly(gray0, polylines1, new Scalar(1), Imgproc.LINE_8, 0, new Point(0, 0));

assertTrue(0 < Core.countNonZero(gray0));

Imgproc.fillPoly(gray0, polylines2, new Scalar(0), Imgproc.LINE_8, 0, new Point(1, 1));

assertEquals(0, Core.countNonZero(gray0));

}

public void testFlip() {

Mat src = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 1.0);

put(0, 1, 2.0);

put(1, 0, 3.0);

put(1, 1, 4.0);

}

};

Mat dst1 = new Mat();

Mat dst2 = new Mat();

Core.flip(src, dst1, 0);

Core.flip(src, dst2, 1);

Mat dst_f1 = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 3.0);

put(0, 1, 4.0);

put(1, 0, 1.0);

put(1, 1, 2.0);

}

};

Mat dst_f2 = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 2.0);

put(0, 1, 1.0);

put(1, 0, 4.0);

put(1, 1, 3.0);

}

};

assertMatEqual(dst_f1, dst1, EPS);

assertMatEqual(dst_f2, dst2, EPS);

}

public void testGemmMatMatDoubleMatDoubleMat() {

Mat m1 = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 1.0, 0.0);

put(1, 0, 1.0, 0.0);

}

};

Mat m2 = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 1.0, 0.0);

put(1, 0, 1.0, 0.0);

}

};

Mat dmatrix = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 0.001, 0.001);

put(1, 0, 0.001, 0.001);

}

};

Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst);

Mat expected = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 1.001, 0.001);

put(1, 0, 1.001, 0.001);

}

};

assertMatEqual(expected, dst, EPS);

}

public void testGemmMatMatDoubleMatDoubleMatInt() {

Mat m1 = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 1.0, 0.0);

put(1, 0, 1.0, 0.0);

}

};

Mat m2 = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 1.0, 0.0);

put(1, 0, 1.0, 0.0);

}

};

Mat dmatrix = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 0.001, 0.001);

put(1, 0, 0.001, 0.001);

}

};

Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst, Core.GEMM_1_T);

Mat expected = new Mat(2, 2, CvType.CV_32FC1) {

{

put(0, 0, 2.001, 0.001);

put(1, 0, 0.001, 0.001);

}

};

assertMatEqual(expected, dst, EPS);

}

public void testGetCPUTickCount() {

long cpuCountStart = 0, actualTickCount;

cpuCountStart = Core.getCPUTickCount();

Core.sumElems(gray255);

actualTickCount = Core.getCPUTickCount();

long expectedTickCount = actualTickCount - cpuCountStart;

assertTrue(expectedTickCount > 0);

}

public void testGetNumberOfCPUs() {

int cpus = Core.getNumberOfCPUs();

assertTrue(Runtime.getRuntime().availableProcessors() <= cpus);

}

public void testGetOptimalDFTSize() {

assertEquals(1, Core.getOptimalDFTSize(0));

assertEquals(135, Core.getOptimalDFTSize(133));

assertEquals(15, Core.getOptimalDFTSize(13));

}

public void testGetTickCount() {

long startCount, endCount, count;

startCount = Core.getTickCount();

Core.divide(gray2, gray1, dst);

endCount = Core.getTickCount();

count = endCount - startCount;

assertTrue(count > 0);

}

public void testGetTickFrequency() {

double freq1 = Core.getTickFrequency();

Core.divide(gray2, gray1, dst);

double freq2 = Core.getTickFrequency();

assertTrue(0 < freq1);

assertEquals(freq1, freq2);

}

public void testHconcat() {

List<Mat> mats = Arrays.asList(Mat.eye(3, 3, CvType.CV_8U), Mat.zeros(3, 2, CvType.CV_8U));

Core.hconcat(mats, dst);

assertMatEqual(Mat.eye(3, 5, CvType.CV_8U), dst);

}

public void testIdctMatMat() {

Mat in = new Mat(1, 8, CvType.CV_32F) {

{

put(0, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);

}

};

Core.idct(in, dst);

truth = new Mat(1, 8, CvType.CV_32F) {

{

put(0, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testIdctMatMatInt() {

Mat in = new Mat(2, 8, CvType.CV_32F) {

{

put(0, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);

put(1, 0, 1.0, 2.0, 1.0, 0.0, 1.0, 2.0, 3.0, 1.0);

}

};

Core.idct(in, dst, Core.DCT_ROWS);

truth = new Mat(2, 8, CvType.CV_32F) {

{

put(0, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);

put(1, 0, 3.3769724, -1.6215782, 2.3608727, 0.20730907, -0.86502546, 0.028082132, -0.7673766, 0.10917115);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testIdftMatMat() {

Mat in = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 1.0, 2.0, 3.0, 4.0);

}

};

Core.idft(in, dst);

truth = new Mat(1, 4, CvType.CV_32F) {

{

put(0, 0, 9, -9, 1, 3);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testIdftMatMatIntInt() {

Mat in = new Mat(2, 4, CvType.CV_32F) {

{

put(0, 0, 1.0, 2.0, 3.0, 4.0);

put(1, 0, 1.0, 2.0, 3.0, 4.0);

}

};

Mat dst = new Mat();

Core.idft(in, dst, Core.DFT_REAL_OUTPUT, 1);

truth = new Mat(2, 4, CvType.CV_32F) {

{

put(0, 0, 18, -18, 2, 6);

put(1, 0, 0, 0, 0, 0);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testInRange() {

gray0.put(1, 1, 100, 150, 200);

Core.inRange(gray0, new Scalar(120), new Scalar(160), dst);

byte vals[] = new byte[3];

dst.get(1, 1, vals);

assertEquals(0, vals[0]);

assertEquals(-1, vals[1]);

assertEquals(0, vals[2]);

assertEquals(1, Core.countNonZero(dst));

}

public void testInsertChannel() {

Core.insertChannel(gray0, rgba128, 0);

Core.insertChannel(gray0, rgba128, 1);

Core.insertChannel(gray0, rgba128, 2);

Core.insertChannel(gray0, rgba128, 3);

assertMatEqual(rgba0, rgba128);

}

public void testInvertMatMat() {

Mat src = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 1.0);

put(0, 1, 2.0);

put(1, 0, 1.5);

put(1, 1, 4.0);

}

};

Core.invert(src, dst);

truth = new Mat(2, 2, CvType.CV_32F) {

{

put(0, 0, 4.0);

put(0, 1, -2.0);

put(1, 0, -1.5);

put(1, 1, 1.0);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testInvertMatMatInt() {

Mat src = Mat.eye(3, 3, CvType.CV_32FC1);

src.put(0, 2, 1);

double cond = Core.invert(src, dst, Core.DECOMP_SVD);

truth = Mat.eye(3, 3, CvType.CV_32FC1);

truth.put(0, 2, -1);

assertMatEqual(truth, dst, EPS);

assertEquals(0.3819660544395447, cond, EPS);

}

public void testKmeansMatIntMatTermCriteriaIntInt() {

Mat data = new Mat(4, 5, CvType.CV_32FC1) {

{

put(0, 0, 1, 2, 3, 4, 5);

put(1, 0, 2, 3, 4, 5, 6);

put(2, 0, 5, 4, 3, 2, 1);

put(3, 0, 6, 5, 4, 3, 2);

}

};

TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, EPS);

Mat labels = new Mat();

Core.kmeans(data, 2, labels, criteria, 1, Core.KMEANS_PP_CENTERS);

int[] first_center = new int[1];

labels.get(0, 0, first_center);

final int c1 = first_center[0];

Mat expected_labels = new Mat(4, 1, CvType.CV_32S) {

{

put(0, 0, c1, c1, 1 - c1, 1 - c1);

}

};

assertMatEqual(expected_labels, labels);

}

public void testKmeansMatIntMatTermCriteriaIntIntMat() {

Mat data = new Mat(4, 5, CvType.CV_32FC1) {

{

put(0, 0, 1, 2, 3, 4, 5);

put(1, 0, 2, 3, 4, 5, 6);

put(2, 0, 5, 4, 3, 2, 1);

put(3, 0, 6, 5, 4, 3, 2);

}

};

TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, EPS);

Mat labels = new Mat();

Mat centers = new Mat();

Core.kmeans(data, 2, labels, criteria, 6, Core.KMEANS_RANDOM_CENTERS, centers);

int[] first_center = new int[1];

labels.get(0, 0, first_center);

final int c1 = first_center[0];

Mat expected_labels = new Mat(4, 1, CvType.CV_32S) {

{

put(0, 0, c1, c1, 1 - c1, 1 - c1);

}

};

Mat expected_centers = new Mat(2, 5, CvType.CV_32FC1) {

{

put(c1, 0, 1.5, 2.5, 3.5, 4.5, 5.5);

put(1 - c1, 0, 5.5, 4.5, 3.5, 2.5, 1.5);

}

};

assertMatEqual(expected_labels, labels);

assertMatEqual(expected_centers, centers, EPS);

}

public void testLineMatPointPointScalar() {

int nPoints = Math.min(gray0.cols(), gray0.rows());

Point point1 = new Point(0, 0);

Point point2 = new Point(nPoints, nPoints);

Scalar color = new Scalar(255);

Imgproc.line(gray0, point1, point2, color);

assertTrue(nPoints == Core.countNonZero(gray0));

}

public void testLineMatPointPointScalarInt() {

int nPoints = Math.min(gray0.cols(), gray0.rows());

Point point1 = new Point(0, 0);

Point point2 = new Point(nPoints, nPoints);

Imgproc.line(gray0, point1, point2, colorWhite, 0);

assertTrue(nPoints == Core.countNonZero(gray0));

}

public void testLineMatPointPointScalarIntIntInt() {

int nPoints = Math.min(gray0.cols(), gray0.rows());

Point point1 = new Point(3, 4);

Point point2 = new Point(nPoints, nPoints);

Point point1_4 = new Point(3 * 4, 4 * 4);

Point point2_4 = new Point(nPoints * 4, nPoints * 4);

Imgproc.line(gray0, point2, point1, colorWhite, 2, Imgproc.LINE_8, 0);

assertFalse(0 == Core.countNonZero(gray0));

Imgproc.line(gray0, point2_4, point1_4, colorBlack, 2, Imgproc.LINE_8, 2);

assertEquals(0, Core.countNonZero(gray0));

}

public void testLog() {

Mat in = new Mat(1, 4, CvType.CV_32FC1) {

{

put(0, 0, 1.0, 10.0, 100.0, 1000.0);

}

};

Core.log(in, dst);

Mat expected = new Mat(1, 4, CvType.CV_32FC1) {

{

put(0, 0, 0, 2.3025851, 4.6051702, 6.9077554);

}

};

assertMatEqual(expected, dst, EPS);

}

public void testLUTMatMatMat() {

Mat lut = new Mat(1, 256, CvType.CV_8UC1);

lut.setTo(new Scalar(0));

Core.LUT(grayRnd, lut, dst);

assertMatEqual(gray0, dst);

lut.setTo(new Scalar(255));

Core.LUT(grayRnd, lut, dst);

assertMatEqual(gray255, dst);

}

public void testMagnitude() {

Mat x = new Mat(1, 4, CvType.CV_32F);

Mat y = new Mat(1, 4, CvType.CV_32F);

x.put(0, 0, 3.0, 5.0, 9.0, 6.0);

y.put(0, 0, 4.0, 12.0, 40.0, 8.0);

Core.magnitude(x, y, dst);

Mat out = new Mat(1, 4, CvType.CV_32F);

out.put(0, 0, 5.0, 13.0, 41.0, 10.0);

assertMatEqual(out, dst, EPS);

Core.magnitude(gray0_32f, gray255_32f, dst);

assertMatEqual(gray255_32f, dst, EPS);

}

public void testMahalanobis() {

Mat covar = new Mat(matSize, matSize, CvType.CV_32F);

Mat mean = new Mat(1, matSize, CvType.CV_32F);

Core.calcCovarMatrix(grayRnd_32f, covar, mean, Core.COVAR_ROWS | Core.COVAR_NORMAL, CvType.CV_32F);

covar = covar.inv();

Mat line1 = grayRnd_32f.row(0);

Mat line2 = grayRnd_32f.row(1);

double d = Core.Mahalanobis(line1, line1, covar);

assertEquals(0.0, d);

d = Core.Mahalanobis(line1, line2, covar);

assertTrue(d > 0.0);

}

public void testMax() {

Core.max(gray0, gray255, dst);

assertMatEqual(gray255, dst);

Mat x = new Mat(1, 1, CvType.CV_32F);

Mat y = new Mat(1, 1, CvType.CV_32F);

x.put(0, 0, 23.0);

y.put(0, 0, 4.0);

Core.max(x, y, dst);

Mat truth = new Mat(1, 1, CvType.CV_32F);

truth.put(0, 0, 23.0);

assertMatEqual(truth, dst, EPS);

}

public void testMeanMat() {

Scalar mean = Core.mean(makeMask(gray128));

assertScalarEqual(new Scalar(64), mean, EPS);

}

public void testMeanMatMat() {

Mat mask1 = makeMask(gray1.clone());

Mat mask2 = makeMask(gray0, 1);

Scalar mean1 = Core.mean(grayRnd, mask1);

Scalar mean2 = Core.mean(grayRnd, mask2);

Scalar mean = Core.mean(grayRnd, gray1);

assertScalarEqual(mean, new Scalar(0.5 * (mean1.val[0] + mean2.val[0])), EPS);

}

public void testMeanStdDevMatMatMat() {