public void testAdjustROI() {

Mat roi = gray0.submat(3, 5, 7, 10);

Mat originalroi = roi.clone();

Mat adjusted = roi.adjustROI(2, 2, 2, 2);

assertMatEqual(adjusted, roi);

assertSizeEquals(new Size(5, 6), adjusted.size(), EPS);

assertEquals(originalroi.type(), adjusted.type());

assertTrue(adjusted.isSubmatrix());

assertFalse(adjusted.isContinuous());

Point offset = new Point();

Size size = new Size();

adjusted.locateROI(size, offset);

assertPointEquals(new Point(5, 1), offset, EPS);

assertSizeEquals(gray0.size(), size, EPS);

}

public void testAssignToMat() {

gray0.assignTo(dst);

assertMatEqual(gray0, dst);

gray255.assignTo(dst);

assertMatEqual(gray255, dst);

}

public void testAssignToMatInt() {

gray255.assignTo(dst, CvType.CV_32F);

assertMatEqual(gray255_32f, dst, EPS);

}

public void testChannels() {

assertEquals(1, gray0.channels());

assertEquals(3, rgbLena.channels());

assertEquals(4, rgba0.channels());

}

public void testCheckVectorInt() {

// ! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel

// (1 x N) or (N x 1); negative number otherwise

assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10));

assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10));

assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10));

assertEquals(10, new Mat(1, 10, CvType.CV_8UC2).checkVector(2));

assertTrue(0 > new Mat().checkVector(0));

assertTrue(0 > new Mat(10, 1, CvType.CV_8U).checkVector(10));

assertTrue(0 > new Mat(10, 20, CvType.CV_8U).checkVector(10));

}

public void testCheckVectorIntInt() {

assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8U));

assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U));

assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U));

assertEquals(10, new Mat(1, 10, CvType.CV_8UC2).checkVector(2, CvType.CV_8U));

assertTrue(0 > new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8S));

assertTrue(0 > new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S));

assertTrue(0 > new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S));

assertTrue(0 > new Mat(1, 10, CvType.CV_8UC2).checkVector(10, CvType.CV_8S));

}

public void testCheckVectorIntIntBoolean() {

Mat mm = new Mat(5, 1, CvType.CV_8UC(10));

Mat roi = new Mat(5, 3, CvType.CV_8UC(10)).submat(1, 3, 2, 3);

assertEquals(5, mm.checkVector(10, CvType.CV_8U, true));

assertEquals(5, mm.checkVector(10, CvType.CV_8U, false));

assertEquals(2, roi.checkVector(10, CvType.CV_8U, false));

assertTrue(0 > roi.checkVector(10, CvType.CV_8U, true));

}

public void testClone() {

dst = gray0.clone();

assertMatEqual(gray0, dst);

assertFalse(gray0.getNativeObjAddr() == dst.getNativeObjAddr());

assertFalse(gray0.dataAddr() == dst.dataAddr());

}

public void testCol() {

Mat col = gray0.col(0);

assertEquals(1, col.cols());

assertEquals(gray0.rows(), col.rows());

}

public void testColRangeIntInt() {

Mat cols = gray0.colRange(0, gray0.cols() / 2);

assertEquals(gray0.cols() / 2, cols.cols());

assertEquals(gray0.rows(), cols.rows());

}

public void testColRangeRange() {

Range range = new Range(0, 5);

dst = gray0.colRange(range);

truth = new Mat(10, 5, CvType.CV_8UC1, new Scalar(0.0));

assertMatEqual(truth, dst);

}

public void testCols() {

assertEquals(matSize, gray0.cols());

}

public void testConvertToMatInt() {

gray255.convertTo(dst, CvType.CV_32F);

truth = new Mat(matSize, matSize, CvType.CV_32F, new Scalar(255));

assertMatEqual(truth, dst, EPS);

}

public void testConvertToMatIntDouble() {

gray2.convertTo(dst, CvType.CV_16U, 2.0);

truth = new Mat(matSize, matSize, CvType.CV_16U, new Scalar(4));

assertMatEqual(truth, dst);

}

public void testConvertToMatIntDoubleDouble() {

gray0_32f.convertTo(dst, CvType.CV_8U, 2.0, 4.0);

truth = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(4));

assertMatEqual(truth, dst);

}

public void testCopyToMat() {

rgbLena.copyTo(dst);

assertMatEqual(rgbLena, dst);

}

public void testCopyToMatMat() {

Mat src = new Mat(4, 4, CvType.CV_8U, new Scalar(5));

Mat mask = makeMask(src.clone());

src.copyTo(dst, mask);

truth = new Mat(4, 4, CvType.CV_8U) {

{

put(0, 0, 0, 0, 5, 5);

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

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

put(3, 0, 0, 0, 5, 5);

}

};

assertMatEqual(truth, dst);

}

public void testCreateIntIntInt() {

gray255.create(4, 5, CvType.CV_32F);

assertEquals(4, gray255.rows());

assertEquals(5, gray255.cols());

assertEquals(CvType.CV_32F, gray255.type());

}

public void testCreateSizeInt() {

Size size = new Size(5, 5);

dst.create(size, CvType.CV_16U);

assertEquals(5, dst.rows());

assertEquals(5, dst.cols());

assertEquals(CvType.CV_16U, dst.type());

}

public void testCross() {

Mat answer = new Mat(1, 3, CvType.CV_32F);

answer.put(0, 0, 7.0, 1.0, -5.0);

Mat cross = v1.cross(v2);

assertMatEqual(answer, cross, EPS);

}

public void testDataAddr() {

assertTrue(0 != gray0.dataAddr());

assertEquals(0, new Mat().dataAddr());

}

public void testDepth() {

assertEquals(CvType.CV_8U, gray0.depth());

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

}

public void testDiag() {

dst = gray0.diag();

truth = new Mat(10, 1, CvType.CV_8UC1, new Scalar(0));

assertMatEqual(truth, dst);

}

public void testDiagInt() {

dst = gray255.diag(2);

truth = new Mat(8, 1, CvType.CV_8UC1, new Scalar(255));

assertMatEqual(truth, dst);

}

public void testDiagMat() {

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

dst = Mat.diag(diagVector);

assertMatEqual(grayE_32f, dst, EPS);

}

public void testDiagMat_sqrMatrix() {

try {

dst = Mat.diag(gray255);

} catch (CvException e) {

// expected

}

}

public void testDot() {

double s = v1.dot(v2);

assertEquals(11.0, s);

}

public void testDump() {

assertEquals("[1, 3, 2]", v1.dump());

}

public void testElemSize() {

assertEquals(Byte.SIZE / 8 * gray0.channels(), gray0.elemSize());

assertEquals(Float.SIZE / 8 * gray0_32f.channels(), gray0_32f.elemSize());

assertEquals(Byte.SIZE / 8 * rgbLena.channels(), rgbLena.elemSize());

}

public void testElemSize1() {

assertEquals(Byte.SIZE / 8, gray255.elemSize1());

assertEquals(Double.SIZE / 8, gray0_64f.elemSize1());

assertEquals(Byte.SIZE / 8, rgbLena.elemSize1());

}

public void testEmpty() {

assertTrue(dst.empty());

assertTrue(!gray0.empty());

}

public void testEyeIntIntInt() {

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

assertMatEqual(eye, eye.inv(), EPS);

}

public void testEyeSizeInt() {

Size size = new Size(5, 5);

Mat eye = Mat.eye(size, CvType.CV_32S);

assertEquals(5, Core.countNonZero(eye));

}

public Mat getTestMat(int size, int type) {

Mat m = new Mat(size, size, type);

final int ch = CvType.channels(type);

double buff[] = new double[size*size * ch];

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

for(int j=0; j<size; j++)

for(int k=0; k<ch; k++) {

buff[i*size*ch + j*ch + k] = 100*i + 10*j + k;

}

m.put(0, 0, buff);

return m;

}

public void testGetIntInt_8U() {

Mat m = getTestMat(5, CvType.CV_8UC2);

// whole Mat

assertTrue(Arrays.equals(new double[] {0, 1}, m.get(0, 0)));

assertTrue(Arrays.equals(new double[] {240, 241}, m.get(2, 4)));

assertTrue(Arrays.equals(new double[] {255, 255}, m.get(4, 4)));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

assertTrue(Arrays.equals(new double[] {230, 231}, sm.get(0, 0)));

assertTrue(Arrays.equals(new double[] {255, 255}, sm.get(1, 1)));

}

public void testGetIntInt_32S() {

Mat m = getTestMat(5, CvType.CV_32SC3);

// whole Mat

assertTrue(Arrays.equals(new double[] {0, 1, 2}, m.get(0, 0)));

assertTrue(Arrays.equals(new double[] {240, 241, 242}, m.get(2, 4)));

assertTrue(Arrays.equals(new double[] {440, 441, 442}, m.get(4, 4)));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

assertTrue(Arrays.equals(new double[] {230, 231, 232}, sm.get(0, 0)));

assertTrue(Arrays.equals(new double[] {340, 341, 342}, sm.get(1, 1)));

}

public void testGetIntInt_64F() {

Mat m = getTestMat(5, CvType.CV_64FC1);

// whole Mat

assertTrue(Arrays.equals(new double[] {0}, m.get(0, 0)));

assertTrue(Arrays.equals(new double[] {240}, m.get(2, 4)));

assertTrue(Arrays.equals(new double[] {440}, m.get(4, 4)));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

assertTrue(Arrays.equals(new double[] {230}, sm.get(0, 0)));

assertTrue(Arrays.equals(new double[] {340}, sm.get(1, 1)));

}

public void testGetIntIntByteArray() {

Mat m = getTestMat(5, CvType.CV_8UC3);

byte[] goodData = new byte[9];

byte[] badData = new byte[7];

// whole Mat

int bytesNum = m.get(1, 1, goodData);

assertEquals(9, bytesNum);

assertTrue(Arrays.equals(new byte[] { 110, 111, 112, 120, 121, 122, (byte) 130, (byte) 131, (byte) 132 }, goodData));

try {

m.get(2, 2, badData);

fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");

} catch (UnsupportedOperationException e) {

// expected

}

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

byte buff00[] = new byte[3];

bytesNum = sm.get(0, 0, buff00);

assertEquals(3, bytesNum);

assertTrue(Arrays.equals(new byte[] {(byte) 230, (byte) 231, (byte) 232}, buff00));

byte buff11[] = new byte[3];

bytesNum = sm.get(1, 1, buff11);

assertEquals(3, bytesNum);

assertTrue(Arrays.equals(new byte[] {(byte) 255, (byte) 255, (byte) 255}, buff11));

}

public void testGetIntIntDoubleArray() {

Mat m = getTestMat(5, CvType.CV_64F);

double buff[] = new double[4];

// whole Mat

int bytesNum = m.get(1, 1, buff);

assertEquals(32, bytesNum);

assertTrue(Arrays.equals(new double[] { 110, 120, 130, 140 }, buff));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

double buff00[] = new double[2];

bytesNum = sm.get(0, 0, buff00);

assertEquals(16, bytesNum);

assertTrue(Arrays.equals(new double[] {230, 240}, buff00));

double buff11[] = new double[] {0, 0};

bytesNum = sm.get(1, 1, buff11);

assertEquals(8, bytesNum);

assertTrue(Arrays.equals(new double[] {340, 0}, buff11));

}

public void testGetIntIntFloatArray() {

Mat m = getTestMat(5, CvType.CV_32F);

float buff[] = new float[4];

// whole Mat

int bytesNum = m.get(1, 1, buff);

assertEquals(16, bytesNum);

assertTrue(Arrays.equals(new float[] { 110, 120, 130, 140 }, buff));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

float buff00[] = new float[2];

bytesNum = sm.get(0, 0, buff00);

assertEquals(8, bytesNum);

assertTrue(Arrays.equals(new float[] {230, 240}, buff00));

float buff11[] = new float[] {0, 0};

bytesNum = sm.get(1, 1, buff11);

assertEquals(4, bytesNum);

assertTrue(Arrays.equals(new float[] {340, 0}, buff11));

}

public void testGetIntIntIntArray() {

Mat m = getTestMat(5, CvType.CV_32SC2);

int[] buff = new int[6];

// whole Mat

int bytesNum = m.get(1, 1, buff);

assertEquals(24, bytesNum);

assertTrue(Arrays.equals(new int[] { 110, 111, 120, 121, 130, 131 }, buff));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

int buff00[] = new int[4];

bytesNum = sm.get(0, 0, buff00);

assertEquals(16, bytesNum);

assertTrue(Arrays.equals(new int[] {230, 231, 240, 241}, buff00));

int buff11[] = new int[]{0, 0, 0, 0};

bytesNum = sm.get(1, 1, buff11);

assertEquals(8, bytesNum);

assertTrue(Arrays.equals(new int[] {340, 341, 0, 0}, buff11));

}

public void testGetIntIntShortArray() {

Mat m = getTestMat(5, CvType.CV_16SC2);

short[] buff = new short[6];

// whole Mat

int bytesNum = m.get(1, 1, buff);

assertEquals(12, bytesNum);

assertTrue(Arrays.equals(new short[] { 110, 111, 120, 121, 130, 131 }, buff));

// sub-Mat

Mat sm = m.submat(2, 4, 3, 5);

short buff00[] = new short[4];

bytesNum = sm.get(0, 0, buff00);

assertEquals(8, bytesNum);

assertTrue(Arrays.equals(new short[] {230, 231, 240, 241}, buff00));

short buff11[] = new short[]{0, 0, 0, 0};

bytesNum = sm.get(1, 1, buff11);

assertEquals(4, bytesNum);

assertTrue(Arrays.equals(new short[] {340, 341, 0, 0}, buff11));

}

public void testGetNativeObjAddr() {

assertTrue(0 != gray0.getNativeObjAddr());

}

public void testHeight() {

assertEquals(gray0.rows(), gray0.height());

assertEquals(rgbLena.rows(), rgbLena.height());

assertEquals(rgba128.rows(), rgba128.height());

}

public void testInv() {

dst = grayE_32f.inv();

assertMatEqual(grayE_32f, dst, EPS);

}

public void testInvInt() {

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

{

put(0, 0, 1.0);

put(0, 1, 2.0);

put(1, 0, 1.5);

put(1, 1, 4.0);

}

};

dst = src.inv(Core.DECOMP_CHOLESKY);

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

{

put(0, 0, 4.0);

put(0, 1, -2.0);

put(1, 0, -1.5);

put(1, 1, 1.0);

}

};

assertMatEqual(truth, dst, EPS);

}

public void testIsContinuous() {

assertTrue(gray0.isContinuous());

Mat subMat = gray0.submat(0, 0, gray0.rows() / 2, gray0.cols() / 2);

assertFalse(subMat.isContinuous());

}

public void testIsSubmatrix() {

assertFalse(gray0.isSubmatrix());

Mat subMat = gray0.submat(0, gray0.rows() / 2, 0, gray0.cols() / 2);

assertTrue(subMat.isSubmatrix());

}

public void testLocateROI() {

Mat roi = gray0.submat(3, 5, 7, 10);

Point offset = new Point();

Size size = new Size();

roi.locateROI(size, offset);

assertPointEquals(new Point(7, 3), offset, EPS);

assertSizeEquals(new Size(10, 10), size, EPS);

}

public void testMat() {

Mat m = new Mat();

assertNotNull(m);

assertTrue(m.empty());

}

public void testMatIntIntCvType() {

Mat gray = new Mat(1, 1, CvType.CV_8UC1);

assertFalse(gray.empty());

Mat rgb = new Mat(1, 1, CvType.CV_8UC3);

assertFalse(rgb.empty());

}

public void testMatIntIntCvTypeScalar() {

dst = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));

assertFalse(dst.empty());

assertMatEqual(dst, gray127);

dst = new Mat(rgba128.rows(), rgba128.cols(), CvType.CV_8UC4, Scalar.all(128));

assertFalse(dst.empty());

assertMatEqual(dst, rgba128);

}

public void testMatIntIntInt() {

Mat gray = new Mat(1, 1, CvType.CV_8U);

assertFalse(gray.empty());

Mat rgb = new Mat(1, 1, CvType.CV_8U);

assertFalse(rgb.empty());

}

public void testMatIntIntIntScalar() {

Mat m1 = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));

assertFalse(m1.empty());

assertMatEqual(m1, gray127);

Mat m2 = new Mat(gray0_32f.rows(), gray0_32f.cols(), CvType.CV_32F, new Scalar(0));

assertFalse(m2.empty());

assertMatEqual(m2, gray0_32f, EPS);

}

public void testMatMatRange() {

dst = new Mat(gray0, new Range(0, 5));

truth = new Mat(5, 10, CvType.CV_8UC1, new Scalar(0));

assertFalse(dst.empty());

assertMatEqual(truth, dst);

}

public void testMatMatRangeRange() {

dst = new Mat(gray255_32f, new Range(0, 5), new Range(0, 5));

truth = new Mat(5, 5, CvType.CV_32FC1, new Scalar(255));

assertFalse(dst.empty());

assertMatEqual(truth, dst, EPS);

}

public void testMatMatRect() {

Mat m = new Mat(7, 6, CvType.CV_32SC1);

m.put(0, 0,

0, 1, 2, 3, 4, 5,

10, 11, 12, 13, 14, 15,

20, 21, 22, 23, 24, 25,

30, 31, 32, 33, 34, 35,

40, 41, 42, 43, 44, 45,

50, 51, 52, 53, 54, 55,

60, 61, 62, 63, 64, 65 );

dst = new Mat(m, new Rect(1, 2, 3, 4));

truth = new Mat(4, 3, CvType.CV_32SC1);

truth.put(0, 0,

21, 22, 23,

31, 32, 33,

41, 42, 43,

51, 52, 53 );

assertFalse(dst.empty());

assertMatEqual(truth, dst);

}

public void testMatSizeInt() {

dst = new Mat(new Size(10, 10), CvType.CV_8U);

assertFalse(dst.empty());

}

public void testMatSizeIntScalar() {

dst = new Mat(new Size(10, 10), CvType.CV_32F, new Scalar(255));

assertFalse(dst.empty());

assertMatEqual(gray255_32f, dst, EPS);

}

public void testMulMat() {

assertMatEqual(gray0, gray0.mul(gray255));

Mat m1 = new Mat(2, 2, CvType.CV_32F, new Scalar(2));

Mat m2 = new Mat(2, 2, CvType.CV_32F, new Scalar(3));

dst = m1.mul(m2);

truth = new Mat(2, 2, CvType.CV_32F, new Scalar(6));

assertMatEqual(truth, dst, EPS);

}

public void testMulMatDouble() {

Mat m1 = new Mat(2, 2, CvType.CV_32F, new Scalar(2));

Mat m2 = new Mat(2, 2, CvType.CV_32F, new Scalar(3));

dst = m1.mul(m2, 3.0);

truth = new Mat(2, 2, CvType.CV_32F, new Scalar(18));

assertMatEqual(truth, dst, EPS);

}

public void testOnesIntIntInt() {

dst = Mat.ones(matSize, matSize, CvType.CV_32F);

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

assertMatEqual(truth, dst, EPS);

}

public void testOnesSizeInt() {

dst = Mat.ones(new Size(2, 2), CvType.CV_16S);

truth = new Mat(2, 2, CvType.CV_16S, new Scalar(1));

assertMatEqual(truth, dst);

}

public void testPush_back() {

Mat m1 = new Mat(2, 4, CvType.CV_32F, new Scalar(2));

Mat m2 = new Mat(3, 4, CvType.CV_32F, new Scalar(3));

m1.push_back(m2);

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

{

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

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

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

put(3, 0, 3, 3, 3, 3);

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

}

};

assertMatEqual(truth, m1, EPS);

}

public void testPutIntIntByteArray() {

Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));

Mat sm = m.submat(2, 4, 3, 5);

byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };

byte[] buff0 = new byte[] { 10, 20, 30, 40, 50, 60 };

byte[] buff1 = new byte[] { -1, -2, -3, -4, -5, -6 };

int bytesNum = m.put(1, 2, buff0);

assertEquals(6, bytesNum);

bytesNum = m.get(1, 2, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, buff0));

bytesNum = sm.put(0, 0, buff1);

assertEquals(6, bytesNum);

bytesNum = sm.get(0, 0, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, buff1));

bytesNum = m.get(2, 3, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, buff1));

Mat m1 = m.row(1);

bytesNum = m1.get(0, 2, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, buff0));

try {

byte[] bytes2 = new byte[] { 10, 20, 30, 40, 50 };

m.put(2, 2, bytes2);

fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");

} catch (UnsupportedOperationException e) {

// expected

}

}

public void testPutIntIntDoubleArray() {

Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));

Mat sm = m.submat(2, 4, 3, 5);

byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };

int bytesNum = m.put(1, 2, 10, 20, 30, 40, 50, 60);

assertEquals(6, bytesNum);

bytesNum = m.get(1, 2, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, new byte[]{10, 20, 30, 40, 50, 60}));

bytesNum = sm.put(0, 0, 255, 254, 253, 252, 251, 250);

assertEquals(6, bytesNum);

bytesNum = sm.get(0, 0, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));

bytesNum = m.get(2, 3, buff);

assertEquals(6, bytesNum);

assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));

}

public void testPutIntIntFloatArray() {

Mat m = new Mat(5, 5, CvType.CV_32FC3, new Scalar(1, 2, 3));

float[] elements = new float[] { 10, 20, 30, 40, 50, 60 };

int bytesNum = m.put(4, 3, elements);

assertEquals(elements.length * 4, bytesNum);

Mat m1 = m.row(4);

float buff[] = new float[3];

bytesNum = m1.get(0, 4, buff);

assertEquals(buff.length * 4, bytesNum);

assertTrue(Arrays.equals(new float[]{40, 50, 60}, buff));

assertArrayEquals(new double[]{10, 20, 30}, m.get(4, 3), EPS);

try {

float[] elements2 = new float[] { 10, 20, 30, 40, 50 };

m.put(2, 2, elements2);

fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");

} catch (UnsupportedOperationException e) {

// expected

}

}

public void testPutIntIntIntArray() {

Mat m = new Mat(5, 5, CvType.CV_32SC3, new Scalar(-1, -2, -3));

int[] elements = new int[] { 10, 20, 30, 40, 50, 60 };

int bytesNum = m.put(0, 4, elements);

assertEquals(elements.length * 4, bytesNum);

Mat m1 = m.col(4);

int buff[] = new int[3];

bytesNum = m1.get(0, 0, buff);

assertEquals(buff.length * 4, bytesNum);

assertTrue(Arrays.equals(new int[]{10, 20, 30}, buff));

assertArrayEquals(new double[]{40, 50, 60}, m.get(1, 0), EPS);

try {

int[] elements2 = new int[] { 10, 20, 30, 40, 50 };

m.put(2, 2, elements2);

fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");

} catch (UnsupportedOperationException e) {

// expected

}

}

public void testPutIntIntShortArray() {

Mat m = new Mat(5, 5, CvType.CV_16SC3, new Scalar(-1, -2, -3));

short[] elements = new short[] { 10, 20, 30, 40, 50, 60 };

int bytesNum = m.put(2, 3, elements);

assertEquals(elements.length * 2, bytesNum);

Mat m1 = m.col(3);

short buff[] = new short[3];

bytesNum = m1.get(2, 0, buff);

assertTrue(Arrays.equals(new short[]{10, 20, 30}, buff));

assertArrayEquals(new double[]{40, 50, 60}, m.get(2, 4), EPS);

try {

short[] elements2 = new short[] { 10, 20, 30, 40, 50 };

m.put(2, 2, elements2);

fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");

} catch (UnsupportedOperationException e) {

// expected

}

}

public void testRelease() {

assertFalse(gray0.empty());

assertTrue(gray0.rows() > 0);

gray0.release();

assertTrue(gray0.empty());

assertEquals(0, gray0.rows());

assertEquals(0, gray0.dataAddr());

}

public void testReshapeInt() {

Mat src = new Mat(4, 4, CvType.CV_8U, new Scalar(0));

dst = src.reshape(4);

truth = new Mat(4, 1, CvType.CV_8UC4, new Scalar(0));

assertMatEqual(truth, dst);

}

public void testReshapeIntInt() {

Mat src = new Mat(5, 7, CvType.CV_8U, new Scalar(0));

dst = src.reshape(7, 5);

truth = new Mat(5, 1, CvType.CV_8UC(7), new Scalar(0));

assertMatEqual(truth, dst);

}

public void testRow() {

Mat row = gray0.row(0);

assertEquals(1, row.rows());

assertEquals(gray0.cols(), row.cols());

}

public void testRowRangeIntInt() {

Mat rows = gray0.rowRange(0, gray0.rows() / 2);

assertEquals(gray0.rows() / 2, rows.rows());

assertEquals(gray0.cols(), rows.cols());

}

public void testRowRangeRange() {

Mat rows = gray255.rowRange(new Range(0, 5));

assertEquals(gray255.rows() / 2, rows.rows());

assertEquals(gray255.cols(), rows.cols());

}

public void testRows() {

assertEquals(matSize, gray0.rows());

}

public void testSetToMat() {

Mat vals = new Mat(7, 1, CvType.CV_8U) {

{

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

}

};

Mat dst = new Mat(1, 1, CvType.CV_8UC(7));

dst.setTo(vals);

Mat truth = new Mat(1, 1, CvType.CV_8UC(7)) {

{

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

}

};

assertMatEqual(truth, dst);

}

public void testSetToMatMat() {

Mat vals = new Mat(7, 1, CvType.CV_8U) {

{

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

}

};

Mat dst = Mat.zeros(2, 1, CvType.CV_8UC(7));

Mat mask = new Mat(2, 1, CvType.CV_8U) {

{

put(0, 0, 0, 1);

}

};

dst.setTo(vals, mask);

Mat truth = new Mat(2, 1, CvType.CV_8UC(7)) {

{

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

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

}

};

assertMatEqual(truth, dst);

}

public void testSetToScalar() {

gray0.setTo(new Scalar(127));

assertMatEqual(gray127, gray0);

}

public void testSetToScalarMask() {

Mat mask = gray0.clone();

mask.put(1, 1, 1, 2, 3);

gray0.setTo(new Scalar(1), mask);

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

Core.subtract(gray0, mask, gray0);

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

}

public void testSize() {

assertEquals(new Size(matSize, matSize), gray0.size());

assertEquals(new Size(3, 1), v1.size());

}

public void testStep1() {

assertEquals(matSize * CvType.channels(CvType.CV_8U), gray0.step1());

assertEquals(3, v2.step1());

}

public void testStep1Int() {

Mat roi = rgba0.submat(3, 5, 7, 10);

Mat m = roi.clone();

assertTrue(rgba0.channels() * rgba0.cols() <= roi.step1(0));

assertEquals(rgba0.channels(), roi.step1(1));

assertTrue(m.channels() * (10 - 7) <= m.step1(0));

assertEquals(m.channels(), m.step1(1));

}

public void testSubmatIntIntIntInt() {

Mat submat = gray0.submat(0, gray0.rows() / 2, 0, gray0.cols() / 2);

assertTrue(submat.isSubmatrix());

assertFalse(submat.isContinuous());

assertEquals(gray0.rows() / 2, submat.rows());

assertEquals(gray0.cols() / 2, submat.cols());

}

public void testSubmatRangeRange() {

Mat submat = gray255.submat(new Range(2, 4), new Range(2, 4));

assertTrue(submat.isSubmatrix());

assertFalse(submat.isContinuous());

assertEquals(2, submat.rows());

assertEquals(2, submat.cols());

}

public void testSubmatRect() {

Mat submat = gray255.submat(new Rect(5, gray255.rows() / 2, 5, gray255.cols() / 2));

assertTrue(submat.isSubmatrix());

assertFalse(submat.isContinuous());

assertEquals(gray255.rows() / 2, submat.rows());

assertEquals(gray255.cols() / 2, submat.cols());

}

public void testT() {

assertMatEqual(gray255, gray255.t());

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

{

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

put(1, 0, 7, 5, 0);

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