Home | History | Annotate | Download | only in test
      1 package org.opencv.test.core;
      2 
      3 import org.opencv.core.Point;
      4 import org.opencv.core.Rect;
      5 import org.opencv.core.RotatedRect;
      6 import org.opencv.core.Size;
      7 import org.opencv.test.OpenCVTestCase;
      8 
      9 public class RotatedRectTest extends OpenCVTestCase {
     10 
     11     private double angle;
     12     private Point center;
     13     private Size size;
     14 
     15     @Override
     16     protected void setUp() throws Exception {
     17         super.setUp();
     18 
     19         center = new Point(matSize / 2, matSize / 2);
     20         size = new Size(matSize / 4, matSize / 2);
     21         angle = 40;
     22     }
     23 
     24     public void testBoundingRect() {
     25         size = new Size(matSize / 2, matSize / 2);
     26         assertEquals(size.height, size.width);
     27         double length = size.height;
     28 
     29         angle = 45;
     30         RotatedRect rr = new RotatedRect(center, size, angle);
     31 
     32         Rect r = rr.boundingRect();
     33         double halfDiagonal = length * Math.sqrt(2) / 2;
     34 
     35         assertTrue((r.x == Math.floor(center.x - halfDiagonal)) && (r.y == Math.floor(center.y - halfDiagonal)));
     36 
     37         assertTrue((r.br().x >= Math.ceil(center.x + halfDiagonal)) && (r.br().y >= Math.ceil(center.y + halfDiagonal)));
     38 
     39         assertTrue((r.br().x - Math.ceil(center.x + halfDiagonal)) <= 1 && (r.br().y - Math.ceil(center.y + halfDiagonal)) <= 1);
     40     }
     41 
     42     public void testClone() {
     43         RotatedRect rrect = new RotatedRect(center, size, angle);
     44         RotatedRect clone = rrect.clone();
     45 
     46         assertTrue(clone != null);
     47         assertTrue(rrect.center.equals(clone.center));
     48         assertTrue(rrect.size.equals(clone.size));
     49         assertTrue(rrect.angle == clone.angle);
     50     }
     51 
     52     public void testEqualsObject() {
     53         Point center2 = new Point(matSize / 3, matSize / 1.5);
     54         Size size2 = new Size(matSize / 2, matSize / 4);
     55         double angle2 = 0;
     56 
     57         RotatedRect rrect1 = new RotatedRect(center, size, angle);
     58         RotatedRect rrect2 = new RotatedRect(center2, size2, angle2);
     59         RotatedRect rrect3 = rrect1;
     60         RotatedRect clone1 = rrect1.clone();
     61         RotatedRect clone2 = rrect2.clone();
     62 
     63         assertTrue(rrect1.equals(rrect3));
     64         assertTrue(!rrect1.equals(rrect2));
     65 
     66         assertTrue(rrect2.equals(clone2));
     67         clone2.angle = 10;
     68         assertTrue(!rrect2.equals(clone2));
     69 
     70         assertTrue(rrect1.equals(clone1));
     71 
     72         clone1.center.x += 1;
     73         assertTrue(!rrect1.equals(clone1));
     74 
     75         clone1.center.x -= 1;
     76         assertTrue(rrect1.equals(clone1));
     77 
     78         clone1.size.width += 1;
     79         assertTrue(!rrect1.equals(clone1));
     80 
     81         assertTrue(!rrect1.equals(size));
     82     }
     83 
     84     public void testHashCode() {
     85         RotatedRect rr = new RotatedRect(center, size, angle);
     86         assertEquals(rr.hashCode(), rr.hashCode());
     87     }
     88 
     89     public void testPoints() {
     90         RotatedRect rrect = new RotatedRect(center, size, angle);
     91 
     92         Point p[] = new Point[4];
     93         rrect.points(p);
     94 
     95         boolean is_p0_irrational = (100 * p[0].x != (int) (100 * p[0].x)) && (100 * p[0].y != (int) (100 * p[0].y));
     96         boolean is_p1_irrational = (100 * p[1].x != (int) (100 * p[1].x)) && (100 * p[1].y != (int) (100 * p[1].y));
     97         boolean is_p2_irrational = (100 * p[2].x != (int) (100 * p[2].x)) && (100 * p[2].y != (int) (100 * p[2].y));
     98         boolean is_p3_irrational = (100 * p[3].x != (int) (100 * p[3].x)) && (100 * p[3].y != (int) (100 * p[3].y));
     99 
    100         assertTrue(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational);
    101 
    102         assertTrue("Symmetric points 0 and 2",
    103                 Math.abs((p[0].x + p[2].x) / 2 - center.x) + Math.abs((p[0].y + p[2].y) / 2 - center.y) < EPS);
    104 
    105         assertTrue("Symmetric points 1 and 3",
    106                 Math.abs((p[1].x + p[3].x) / 2 - center.x) + Math.abs((p[1].y + p[3].y) / 2 - center.y) < EPS);
    107 
    108         assertTrue("Orthogonal vectors 01 and 12",
    109                 Math.abs((p[1].x - p[0].x) * (p[2].x - p[1].x) +
    110                         (p[1].y - p[0].y) * (p[2].y - p[1].y)) < EPS);
    111 
    112         assertTrue("Orthogonal vectors 12 and 23",
    113                 Math.abs((p[2].x - p[1].x) * (p[3].x - p[2].x) +
    114                         (p[2].y - p[1].y) * (p[3].y - p[2].y)) < EPS);
    115 
    116         assertTrue("Orthogonal vectors 23 and 30",
    117                 Math.abs((p[3].x - p[2].x) * (p[0].x - p[3].x) +
    118                         (p[3].y - p[2].y) * (p[0].y - p[3].y)) < EPS);
    119 
    120         assertTrue("Orthogonal vectors 30 and 01",
    121                 Math.abs((p[0].x - p[3].x) * (p[1].x - p[0].x) +
    122                         (p[0].y - p[3].y) * (p[1].y - p[0].y)) < EPS);
    123 
    124         assertTrue("Length of the vector 01",
    125                 Math.abs((p[1].x - p[0].x) * (p[1].x - p[0].x) +
    126                         (p[1].y - p[0].y) * (p[1].y - p[0].y) - size.height * size.height) < EPS);
    127 
    128         assertTrue("Length of the vector 21",
    129                 Math.abs((p[1].x - p[2].x) * (p[1].x - p[2].x) +
    130                         (p[1].y - p[2].y) * (p[1].y - p[2].y) - size.width * size.width) < EPS);
    131 
    132         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)) < EPS);
    133     }
    134 
    135     public void testRotatedRect() {
    136         RotatedRect rr = new RotatedRect();
    137 
    138         assertTrue(rr != null);
    139         assertTrue(rr.center != null);
    140         assertTrue(rr.size != null);
    141         assertTrue(rr.angle == 0.0);
    142     }
    143 
    144     public void testRotatedRectDoubleArray() {
    145         double[] vals = { 1.5, 2.6, 3.7, 4.2, 5.1 };
    146         RotatedRect rr = new RotatedRect(vals);
    147 
    148         assertNotNull(rr);
    149         assertEquals(1.5, rr.center.x);
    150         assertEquals(2.6, rr.center.y);
    151         assertEquals(3.7, rr.size.width);
    152         assertEquals(4.2, rr.size.height);
    153         assertEquals(5.1, rr.angle);
    154     }
    155 
    156     public void testRotatedRectPointSizeDouble() {
    157         RotatedRect rr = new RotatedRect(center, size, 40);
    158 
    159         assertTrue(rr != null);
    160         assertTrue(rr.center != null);
    161         assertTrue(rr.size != null);
    162         assertTrue(rr.angle == 40.0);
    163     }
    164 
    165     public void testSet() {
    166         double[] vals1 = {};
    167         RotatedRect r1 = new RotatedRect(center, size, 40);
    168 
    169         r1.set(vals1);
    170 
    171         assertEquals(0., r1.angle);
    172         assertPointEquals(new Point(0, 0), r1.center, EPS);
    173         assertSizeEquals(new Size(0, 0), r1.size, EPS);
    174 
    175         double[] vals2 = { 1, 2, 3, 4, 5 };
    176         RotatedRect r2 = new RotatedRect(center, size, 40);
    177 
    178         r2.set(vals2);
    179 
    180         assertEquals(5., r2.angle);
    181         assertPointEquals(new Point(1, 2), r2.center, EPS);
    182         assertSizeEquals(new Size(3, 4), r2.size, EPS);
    183     }
    184 
    185     public void testToString() {
    186         String actual = new RotatedRect(new Point(1, 2), new Size(10, 12), 4.5).toString();
    187         String expected = "{ {1.0, 2.0} 10x12 * 4.5 }";
    188         assertEquals(expected, actual);
    189     }
    190 
    191 }
    192