Mostly working with the official OpenCV java bindings

* still unable to pass in covariance matrices to EM.trainE()

src/ImageJ/Demo_Pixel_Replication.java

@@ -17,8 +17,10 @@ import org.opencv.core.Mat;
 import org.opencv.core.CvType;
 import org.opencv.core.Scalar;
 import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Size;
 import org.opencv.ml.*;
 import org.opencv.imgproc.Imgproc;
+import org.opencv.utils.Converters;
 
 // import org.bytedeco.javacpp.indexer.*;
 // import org.bytedeco.javacpp.indexer.DoubleIndexer;
@@ -42,6 +44,7 @@ public class Demo_Pixel_Replication implements PlugInFilter {
         UniqPts = new ArrayList<>();
         PrPts = new ArrayList<>();
         rnd = new Random();
+        // Core.setRNGSeed(rnd.nextInt());
     }
 
     public int setup(String arg, ImagePlus imp) {
@@ -74,17 +77,17 @@ public class Demo_Pixel_Replication implements PlugInFilter {
         if (!showDialog())
             return;
 
-        Mat ipl = ip2mat(ip);
+        Mat ipMat = ip2mat(ip);
         Rectangle r = ip.getRoi();
 
         // use distance transform to populate UniqPts and PrPts
-        Mat distMat = DistTransform(ipl);
+        Mat distMat = DistTransform(ipMat);
         // byte buff[] = new byte[distMat.total() * distMat.channels()];
         // distMat.get(0, 0, buff);
 
         for (int y=r.y; y<(r.y+r.height); y++) {
             for (int x=r.x; x<(r.x+r.width); x++) {
-                double[] val = distMat.get(x,y);
+                double[] val = distMat.get(y, x);
                 long n = (int) Math.round(val[0]);
                 if (n > 0) {
                     Point p = new Point(x, y);
@@ -133,7 +136,7 @@ public class Demo_Pixel_Replication implements PlugInFilter {
             eigVal.get(0, 0, valIdx);
             // DoubleIndexer valIdx = eigVal.createIndexer();
             // if (valIdx.get(0,0) > valIdx.get(1,0)) {
-            if (valIdx[1] > valIdx[0]) {
+            if (valIdx[0] > valIdx[1]) {
                 hi = 0;
                 lo = 1;
             } else {
@@ -161,25 +164,21 @@ public class Demo_Pixel_Replication implements PlugInFilter {
     }
 
     private Mat ip2mat(ImageProcessor src) {
-
         BufferedImage bi = src.getBufferedImage();
         return bufferedImageToMat(bi);
     }
 
-    public static Mat bufferedImageToMat(BufferedImage bi) {
-        Mat mat = new Mat(bi.getHeight(), bi.getWidth(), CvType.CV_8UC3);
+    public Mat bufferedImageToMat(BufferedImage bi) {
+        Mat mat = new Mat(bi.getHeight(), bi.getWidth(), CvType.CV_8U);
         byte[] data = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
         mat.put(0, 0, data);
         return mat;
     }
 
-    private Mat DistTransform(Mat iplIn) {
-        // IplImage iplOut = cvCreateImage(cvGetSize(iplIn), IPL_DEPTH_32F, 1);
-        Mat iplOut = new Mat(iplIn.size(), iplIn.type());
-        // cvDistTransform(iplIn, iplOut);
-        // return iplOut.asCvMat();
-        Imgproc.distanceTransform(iplIn, iplOut, Imgproc.CV_DIST_L2, 3);
-        return iplOut;
+    private Mat DistTransform(Mat matIn) {
+        Mat matOut = new Mat(matIn.size(), CvType.CV_32F);
+        Imgproc.distanceTransform(matIn, matOut, Imgproc.CV_DIST_L2, 3);
+        return matOut;
     }
 
     private Mat PrPts2Mat(ArrayList<Point> PrPts, double pct) {
@@ -215,6 +214,7 @@ public class Demo_Pixel_Replication implements PlugInFilter {
             Mat logLikelihoods = new Mat(PrPts.size(), 1, CvType.CV_64FC1);
             Mat labels = new Mat(PrPts.size(), 1, CvType.CV_32FC1);
             Mat covs0 = makeInitCovs(k);
+            // ArrayList<Mat> covs0 = makeInitCovs(k);
             Mat weights0 = makeInitWeights(k);
             em.setInt("nclusters", k);
             em.setInt("covMatType", EM.COV_MAT_GENERIC);
@@ -250,16 +250,23 @@ public class Demo_Pixel_Replication implements PlugInFilter {
     private double addUp(Mat m) {
         // DoubleIndexer idx = m.createIndexer();
         double total = 0;
-        for (int r = 0; r < m.rows(); r++) {
-            double[] idx = m.get(r, 0);
-            // total += idx.get(r, 0);
-            total += idx[0];
-        }
+        double[] data = new double[(int) m.total()];
+        m.get(0, 0, data);
+
+        for (int i = 0; i < m.total(); i++)
+            total += data[i];
+
+        // for (int r = 0; r < m.rows(); r++) {
+        //     double[] idx = m.get(r, 0);
+        //     // total += idx.get(r, 0);
+        //     total += idx[0];
+        // }
 
         return total;
     }
 
     private Mat makeInitCovs(int k) {
+    // private ArrayList<Mat> makeInitCovs(int k) {
         // Mat covs0 = new Mat(1, 4*k, CV_64FC1); 
         // DoubleIndexer idx = covs0.createIndexer();
         // for (int i = 0; i < 4*k; i += 4) {
@@ -270,7 +277,26 @@ public class Demo_Pixel_Replication implements PlugInFilter {
         // }
 
         // return covs0;
-        return new Mat();
+        // return new Mat();
+        // return Mat.eye(new Size(2,2), CvType.CV_64F);
+
+        IJ.log("eye = " + Mat.eye(new Size(2,2), CvType.CV_64F).dump());
+        IJ.log("eye channels = " + Mat.eye(new Size(2,2), CvType.CV_64F).channels());
+        IJ.log("eye size = " + Mat.eye(new Size(2,2), CvType.CV_64F).size());
+
+        ArrayList<Mat> mats = new ArrayList<Mat>();
+        for (int i = 0; i < k; i++) 
+            mats.add(Mat.eye(new Size(2,2), CvType.CV_64F));
+        // return mats;
+
+        Mat res = Converters.vector_Mat_to_Mat(mats);
+        // res = res.reshape(2, 2);
+        Size size = res.size();
+        IJ.log(String.format("mats.size() = %d, res.size() = %f x %f", mats.size(), size.height, size.width));
+        IJ.log("covs = " + res.dump());
+        IJ.log("res.channels = " + res.channels());
+        IJ.log("res.size = " + res.size());
+        return res;
     }
 
     private Mat makeInitWeights(int k) {
@@ -282,46 +308,57 @@ public class Demo_Pixel_Replication implements PlugInFilter {
         //     idx.put(r, 0, weight);
 
         // return weights0;
-        return new Mat();
+        // return new Mat();
+        return new Mat(k, 1, CvType.CV_64F, new Scalar(1/k));
     }
 
     private EllipseRoi makeEllipseRoi(Mat center, Mat unitVec, double A, double B) {
         Mat end1 = new Mat();
         Mat end2 = new Mat();
 
+        double[] data1 = new double[2];
+        double[] data2 = new double[2];
+
         Core.scaleAdd(unitVec, A, center, end1);
         Core.scaleAdd(unitVec, -A, center, end2);
         double aspectRatio = B / A;
 
-        DoubleIndexer end1Idx = end1.createIndexer();
-        DoubleIndexer end2Idx = end2.createIndexer();
+        end1.get(0, 0, data1);
+        end2.get(0, 0, data2);
 
-        return new EllipseRoi(end1Idx.get(0,0), end1Idx.get(0,1), end2Idx.get(0,0), end2Idx.get(0,1), aspectRatio);
+        // return new EllipseRoi(end1Idx.get(0,0), end1Idx.get(0,1), end2Idx.get(0,0), end2Idx.get(0,1), aspectRatio);
+        return new EllipseRoi(data1[0], data1[1], data2[0], data2[1], aspectRatio);
     }
 
     // Initialize the means by picking 2 distinct points at random from UniqPts.
     // We're using a simple naive algorithm since we assume k << n.
     private Mat randomInitMeans(int k) {
         HashSet<Integer> used = new HashSet<Integer>();
-        Mat means = new Mat(k, 2, CV_64FC1);
-        DoubleIndexer meansIdx = means.createIndexer();
+        Mat means = new Mat(k, 2, CvType.CV_64F);
+        double[] meansData = new double[k * 2];
 
         int i = 0;
+        int n = 0;
         while (i < k) {
             int j = rnd.nextInt(UniqPts.size());
             if (!used.contains(j)) {
                 Point p = UniqPts.get(j);
-                meansIdx.put(i, 0, p.x());
-                meansIdx.put(i, 1, p.y());
+                // meansIdx.put(i, 0, p.x());
+                // meansIdx.put(i, 1, p.y());
+                meansData[n++] = p.x;
+                meansData[n++] = p.y;
                 used.add(j);
-                IJ.log(String.format("random pt %d: (%.0f,%.0f)", i, p.x(), p.y()));
+                IJ.log(String.format("random pt %d: (%d,%d)", i, p.x, p.y));
                 i++;
             }
         }
 
+        means.put(0, 0, meansData);
+
         for (int r = 0; r < means.rows(); r++) {
             for (int c = 0; c < means.cols(); c++) {
-                IJ.log(String.format("means(%d,%d) = %f", r, c, meansIdx.get(r, c)));
+                double[] val = means.get(r, c);
+                IJ.log(String.format("means(%d,%d) = %f", r, c, val[0]));
             }
         }