Added tests for the class.
--- /dev/null
+package org.opencv.test.core;
+
+import org.opencv.Point;
+import org.opencv.Rect;
+import org.opencv.RotatedRect;
+import org.opencv.Size;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class RotatedRectTest extends OpenCVTestCase {
+
+ public void testBoundingRect() {
+ Point center = new Point(matSize/2, matSize/2);
+ double length1 = matSize/4;
+ Size size = new Size(length1, length1);
+ double angle = 45;
+
+ RotatedRect rr = new RotatedRect(center, size, angle);
+
+ Rect r = rr.boundingRect();
+
+ OpenCVTestRunner.Log("testBoundingRect: r="+r.toString());
+ OpenCVTestRunner.Log("testBoundingRect: center.x + length1*Math.sqrt(2)/2="+ (center.x + length1*Math.sqrt(2)/2));
+ OpenCVTestRunner.Log("testBoundingRect: length1*Math.sqrt(2)="+ (length1*Math.sqrt(2)));
+
+ assertTrue(
+ (r.x == Math.floor(center.x - length1*Math.sqrt(2)/2))
+ &&
+ (r.y == Math.floor(center.y - length1*Math.sqrt(2)/2)));
+
+ assertTrue(
+ (r.br().x >= Math.ceil(center.x + length1*Math.sqrt(2)/2))
+ &&
+ (r.br().y >= Math.ceil(center.y + length1*Math.sqrt(2)/2)));
+
+ assertTrue(
+ (r.br().x - Math.ceil(center.x + length1*Math.sqrt(2)/2)) <= 1
+ &&
+ (r.br().y - Math.ceil(center.y + length1*Math.sqrt(2)/2)) <= 1);
+ }
+
+
+ public void testClone() {
+ Point center = new Point(matSize/2, matSize/2);
+ Size size = new Size(matSize/4, matSize/2);
+ double angle = 40;
+
+ RotatedRect rr1 = new RotatedRect(center, size, angle);
+ RotatedRect rr1c = rr1.clone();
+
+ assertTrue(rr1c != null);
+ assertTrue(rr1.center.equals(rr1c.center));
+ assertTrue(rr1.size.equals(rr1c.size));
+ assertTrue(rr1.angle == rr1c.angle);
+ }
+
+ public void testEqualsObject() {
+ Point center = new Point(matSize/2, matSize/2);
+ Size size = new Size(matSize/4, matSize/2);
+ double angle = 40;
+ Point center2 = new Point(matSize/3, matSize/1.5);
+ Size size2 = new Size(matSize/2, matSize/4);
+ double angle2 = 0;
+
+ RotatedRect rr1 = new RotatedRect(center, size, angle);
+ RotatedRect rr2 = new RotatedRect(center2, size2, angle2);
+ RotatedRect rr1c = rr1.clone();
+ RotatedRect rr3 = rr2.clone();
+ RotatedRect rr11=rr1;
+ rr3.angle=10;
+
+ assertTrue(rr1.equals(rr11));
+ assertTrue(!rr1.equals(rr2));
+ assertTrue(rr1.equals(rr1c));
+ assertTrue(!rr2.equals(rr3));
+
+ rr1c.center.x+=1;
+ assertTrue(!rr1.equals(rr1c));
+
+ rr1c.center.x-=1;
+ assertTrue(rr1.equals(rr1c));
+
+ rr1c.size.width+=1;
+ assertTrue(!rr1.equals(rr1c));
+
+ assertTrue(! rr1.equals(size));
+ }
+
+ public void testPoints() {
+ Point center = new Point(matSize/2, matSize/2);
+ Size size = new Size(matSize/4, matSize/2);
+ double angle = 40;
+ RotatedRect rr = new RotatedRect(center, size, angle);
+ Point p[] = new Point[4];
+
+ rr.points(p);
+
+ boolean is_p0_irrational = (100*p[0].x!=(int)(100*p[0].x)) && (100*p[0].y!=(int)(100*p[0].y));
+ boolean is_p1_irrational = (100*p[1].x!=(int)(100*p[1].x)) && (100*p[1].y!=(int)(100*p[1].y));
+ boolean is_p2_irrational = (100*p[2].x!=(int)(100*p[2].x)) && (100*p[2].y!=(int)(100*p[2].y));
+ boolean is_p3_irrational = (100*p[3].x!=(int)(100*p[3].x)) && (100*p[3].y!=(int)(100*p[3].y));
+
+ assertTrue(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational);
+
+ assertTrue("Symmetric points 0 and 2",
+ Math.abs((p[0].x + p[2].x)/2 - center.x) + Math.abs((p[0].y + p[2].y)/2 - center.y) < 0.001);
+
+ assertTrue("Symmetric points 1 and 3",
+ Math.abs((p[1].x + p[3].x)/2 - center.x) + Math.abs((p[1].y + p[3].y)/2 - center.y) < 0.001);
+
+ assertTrue("Orthogonal vectors 01 and 12",
+ Math.abs( (p[1].x - p[0].x) * (p[2].x - p[1].x) + (p[1].y - p[0].y) * (p[2].y - p[1].y) ) < 0.001);
+
+ assertTrue("Orthogonal vectors 12 and 23",
+ Math.abs( (p[2].x - p[1].x) * (p[3].x - p[2].x) + (p[2].y - p[1].y) * (p[3].y - p[2].y) ) < 0.001);
+
+ assertTrue("Orthogonal vectors 23 and 30",
+ Math.abs( (p[3].x - p[2].x) * (p[0].x - p[3].x) + (p[3].y - p[2].y) * (p[0].y - p[3].y) ) < 0.001);
+
+ assertTrue("Orthogonal vectors 30 and 01",
+ Math.abs( (p[0].x - p[3].x) * (p[1].x - p[0].x) + (p[0].y - p[3].y) * (p[1].y - p[0].y) ) < 0.001);
+
+ assertTrue("Length of the vector 01",
+ Math.abs(
+ (p[1].x - p[0].x) * (p[1].x - p[0].x) + (p[1].y - p[0].y)*(p[1].y - p[0].y)
+ -
+ size.height * size.height
+ ) < 0.001);
+
+ assertTrue("Length of the vector 21",
+ Math.abs(
+ (p[1].x - p[2].x) * (p[1].x - p[2].x) + (p[1].y - p[2].y)*(p[1].y - p[2].y)
+ -
+ size.width * size.width
+ ) < 0.001);
+
+ assertTrue("Angle of the vector 21 with the axes",
+ Math.abs(
+ (p[2].x - p[1].x) / size.width
+ -
+ Math.cos(angle * Math.PI / 180)
+ ) < 0.001);
+
+ }
+
+ public void testRotatedRect() {
+ RotatedRect rr = new RotatedRect();
+ assertTrue(rr != null);
+ }
+
+ public void testRotatedRectPointSizeDouble() {
+ RotatedRect rr = new RotatedRect(new Point(matSize/2, matSize/2), new Size(matSize/4, matSize/2), 45);
+ assertTrue(rr != null);
+ }
+
+}
"Rect" : { "j_type" : "Rect", "jn_args" : (("int", ".x"), ("int", ".y"), ("int", ".width"), ("int", ".height")),\r
"jni_var" : "cv::Rect %(n)s(%(n)s_x, %(n)s_y, %(n)s_width, %(n)s_height)",\r
"suffix" : "IIII"},\r
- "Size" : { "j_type" : "Size", "jn_args" : (("int", ".width"), ("int", ".height")),\r
- "jni_var" : "cv::Size %(n)s(%(n)s_width, %(n)s_height)",\r
- "suffix" : "II"},\r
+ "Size" : { "j_type" : "Size", "jn_args" : (("double", ".width"), ("double", ".height")),\r
+ "jni_var" : "cv::Size %(n)s((int)%(n)s_width, (int)%(n)s_height)",\r
+ "suffix" : "DD"},\r
+ "Size2f" : { "j_type" : "Size", "jn_args" : (("double", ".width"), ("double", ".height")),\r
+ "jni_var" : "cv::Size2f %(n)s((float)%(n)s_width, (float)%(n)s_height)",\r
+ "suffix" : "DD"},\r
+ "RotatedRect": { "j_type" : "RotatedRect", "jn_args" : (("double", ".center.x"), ("double", ".center.y"), ("double", ".size.width"), ("double", ".size.height"), ("double", ".angle")),\r
+ "jni_var" : "cv::RotatedRect %(n)s(cv::Point2f(%(n)s_center_x, %(n)s_center_y), cv::Size2f(%(n)s_size_width, %(n)s_size_height), %(n)s_angle)",\r
+ "suffix" : "DDDDD"},\r
"Scalar" : { "j_type" : "Scalar", "jn_args" : (("double", ".v0"), ("double", ".v1"), ("double", ".v2"), ("double", ".v3")),\r
"jni_var" : "cv::Scalar %(n)s(%(n)s_v0, %(n)s_v1, %(n)s_v2, %(n)s_v3)",\r
"suffix" : "DDDD"},\r
public boolean inside(Rect 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
//javadoc:Rect_\r
public class Rect {\r
\r
- int x, y, width, height;\r
+ public int x, y, width, height;\r
\r
public Rect(int x, int y, int width, int height) {\r
this.x = x;\r
}\r
\r
public Rect(Point p, Size s) {\r
- this((int)p.x, (int)p.y, s.width, s.height);\r
+ this((int)p.x, (int)p.y, (int)s.width, (int)s.height);\r
}\r
\r
public Rect clone() {\r
Rect it = (Rect) obj;\r
return x == it.x && y == it.y && width == it.width && height == it.height;\r
}\r
+\r
+ @Override\r
+ public String toString() {\r
+ if (this == null) return "null";\r
+ return "{" + x + ", " + y + ", " + width + "x" + height+"}";\r
+ }\r
}\r
--- /dev/null
+package org.opencv;\r
+\r
+//javadoc:RotatedRect_\r
+public class RotatedRect {\r
+ \r
+ public Point center;\r
+ public Size size;\r
+ public double angle;\r
+\r
+ public RotatedRect() {\r
+ this.angle=0;\r
+ }\r
+\r
+ public RotatedRect(Point c, Size s, double a) {\r
+ this.center = c.clone();\r
+ this.size = s.clone();\r
+ this.angle = a;\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
+\r
+ pt[0] = new Point(\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
+\r
+ pt[2] = new Point(\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
+ }\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
+ r.width -= r.x - 1;\r
+ r.height -= r.y - 1;\r
+ return r;\r
+ } \r
+ \r
+ \r
+ public RotatedRect clone() {\r
+ return new RotatedRect(center, size, angle);\r
+ }\r
+ \r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ long temp;\r
+ temp = Double.doubleToLongBits(center.x);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(center.y);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(size.width);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(size.height);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ temp = Double.doubleToLongBits(angle);\r
+ result = prime * result + (int) (temp ^ (temp >>> 32));\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) return true;\r
+ if (!(obj instanceof RotatedRect)) return false;\r
+ RotatedRect it = (RotatedRect) obj;\r
+ return center.equals(it.center) && size.equals(it.size) && angle == it.angle;\r
+ }\r
+}\r
//javadoc:Size_\r
public class Size {\r
\r
- public int width, height;\r
+ public double width, height;\r
\r
- public Size(int width, int height) {\r
+ public Size(double width, double height) {\r
this.width = width;\r
this.height = height;\r
}\r
}\r
\r
public Size(Point p) {\r
- width = (int) p.x;\r
- height = (int) p.y;\r
+ width = (double) p.x;\r
+ height = (double) p.y;\r
}\r
\r
public double area() {\r