Added Java wrapping for tracking module

modules/core/misc/java/src/java/core+MatOfRect2d.java

@@ -0,0 +1,81 @@
+package org.opencv.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+
+public class MatOfRect2d extends Mat {
+    // 64FC4
+    private static final int _depth = CvType.CV_64F;
+    private static final int _channels = 4;
+
+    public MatOfRect2d() {
+        super();
+    }
+
+    protected MatOfRect2d(long addr) {
+        super(addr);
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public static MatOfRect2d fromNativeAddr(long addr) {
+        return new MatOfRect2d(addr);
+    }
+
+    public MatOfRect2d(Mat m) {
+        super(m, Range.all());
+        if( !empty() && checkVector(_channels, _depth) < 0 )
+            throw new IllegalArgumentException("Incompatible Mat");
+        //FIXME: do we need release() here?
+    }
+
+    public MatOfRect2d(Rect2d...a) {
+        super();
+        fromArray(a);
+    }
+
+    public void alloc(int elemNumber) {
+        if(elemNumber>0)
+            super.create(elemNumber, 1, CvType.makeType(_depth, _channels));
+    }
+
+    public void fromArray(Rect2d...a) {
+        if(a==null || a.length==0)
+            return;
+        int num = a.length;
+        alloc(num);
+        double buff[] = new double[num * _channels];
+        for(int i=0; i<num; i++) {
+            Rect2d r = a[i];
+            buff[_channels*i+0] = (double) r.x;
+            buff[_channels*i+1] = (double) r.y;
+            buff[_channels*i+2] = (double) r.width;
+            buff[_channels*i+3] = (double) r.height;
+        }
+        put(0, 0, buff); //TODO: check ret val!
+    }
+
+
+    public Rect2d[] toArray() {
+        int num = (int) total();
+        Rect2d[] a = new Rect2d[num];
+        if(num == 0)
+            return a;
+        double buff[] = new double[num * _channels];
+        get(0, 0, buff); //TODO: check ret val!
+        for(int i=0; i<num; i++)
+            a[i] = new Rect2d(buff[i*_channels], buff[i*_channels+1], buff[i*_channels+2], buff[i*_channels+3]);
+        return a;
+    }
+    public void fromList(List<Rect2d> lr) {
+        Rect2d ap[] = lr.toArray(new Rect2d[0]);
+        fromArray(ap);
+    }
+
+    public List<Rect2d> toList() {
+        Rect2d[] ar = toArray();
+        return Arrays.asList(ar);
+    }
+}

modules/core/misc/java/src/java/core+Rect2d.java

@@ -0,0 +1,100 @@
+package org.opencv.core;
+
+//javadoc:Rect2d_
+public class Rect2d {
+
+    public double x, y, width, height;
+
+    public Rect2d(double x, double y, double width, double height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+
+    public Rect2d() {
+        this(0, 0, 0, 0);
+    }
+
+    public Rect2d(Point p1, Point p2) {
+        x = (double) (p1.x < p2.x ? p1.x : p2.x);
+        y = (double) (p1.y < p2.y ? p1.y : p2.y);
+        width = (double) (p1.x > p2.x ? p1.x : p2.x) - x;
+        height = (double) (p1.y > p2.y ? p1.y : p2.y) - y;
+    }
+
+    public Rect2d(Point p, Size s) {
+        this((double) p.x, (double) p.y, (double) s.width, (double) s.height);
+    }
+
+    public Rect2d(double[] vals) {
+        set(vals);
+    }
+
+    public void set(double[] vals) {
+        if (vals != null) {
+            x = vals.length > 0 ? (double) vals[0] : 0;
+            y = vals.length > 1 ? (double) vals[1] : 0;
+            width = vals.length > 2 ? (double) vals[2] : 0;
+            height = vals.length > 3 ? (double) vals[3] : 0;
+        } else {
+            x = 0;
+            y = 0;
+            width = 0;
+            height = 0;
+        }
+    }
+
+    public Rect2d clone() {
+        return new Rect2d(x, y, width, height);
+    }
+
+    public Point tl() {
+        return new Point(x, y);
+    }
+
+    public Point br() {
+        return new Point(x + width, y + height);
+    }
+
+    public Size size() {
+        return new Size(width, height);
+    }
+
+    public double area() {
+        return width * height;
+    }
+
+    public boolean contains(Point p) {
+        return x <= p.x && p.x < x + width && y <= p.y && p.y < y + height;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(height);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(width);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(x);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(y);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Rect2d)) return false;
+        Rect2d it = (Rect2d) obj;
+        return x == it.x && y == it.y && width == it.width && height == it.height;
+    }
+
+    @Override
+    public String toString() {
+        return "{" + x + ", " + y + ", " + width + "x" + height + "}";
+    }
+}