Examples with DoubleIndexer org.bytedeco.javacpp.indexer.DoubleIndexer used on opensource projects

Example 1 with DoubleIndexer

use of org.bytedeco.javacpp.indexer.DoubleIndexer in project javacpp by bytedeco.

the class IndexerTest method testDoubleIndexer.

@Test
public void testDoubleIndexer() {
    System.out.println("DoubleIndexer");
    long size = 7 * 5 * 3 * 2;
    long[] sizes = { 7, 5, 3, 2 };
    long[] strides = { 5 * 3 * 2, 3 * 2, 2, 1 };
    final DoublePointer ptr = new DoublePointer(size);
    for (int i = 0; i < size; i++) {
        ptr.position(i).put((double) i);
    }
    DoubleIndexer arrayIndexer = DoubleIndexer.create(ptr.position(0), sizes, strides, false);
    DoubleIndexer directIndexer = DoubleIndexer.create(ptr.position(0), sizes, strides, true);
    int n = 0;
    for (int i = 0; i < sizes[0]; i++) {
        assertEquals(n, arrayIndexer.get(i), 0);
        assertEquals(n, directIndexer.get(i), 0);
        for (int j = 0; j < sizes[1]; j++) {
            assertEquals(n, arrayIndexer.get(i, j), 0);
            assertEquals(n, directIndexer.get(i, j), 0);
            for (int k = 0; k < sizes[2]; k++) {
                assertEquals(n, arrayIndexer.get(i, j, k), 0);
                assertEquals(n, directIndexer.get(i, j, k), 0);
                for (int m = 0; m < sizes[3]; m++) {
                    long[] index = { i, j, k, m };
                    assertEquals(n, arrayIndexer.get(index), 0);
                    assertEquals(n, directIndexer.get(index), 0);
                    arrayIndexer.put(index, (double) (2 * n));
                    directIndexer.put(index, (double) (3 * n));
                    n++;
                }
            }
        }
    }
    try {
        arrayIndexer.get(size);
        fail("IndexOutOfBoundsException should have been thrown.");
    } catch (IndexOutOfBoundsException e) {
    }
    try {
        directIndexer.get(size);
        fail("IndexOutOfBoundsException should have been thrown.");
    } catch (IndexOutOfBoundsException e) {
    }
    System.out.println("arrayIndexer" + arrayIndexer);
    System.out.println("directIndexer" + directIndexer);
    for (int i = 0; i < size; i++) {
        assertEquals(3 * i, ptr.position(i).get(), 0);
    }
    arrayIndexer.release();
    for (int i = 0; i < size; i++) {
        assertEquals(2 * i, ptr.position(i).get(), 0);
    }
    System.gc();
    if (Loader.sizeof(Pointer.class) > 4)
        try {
            long longSize = 0x80000000L + 8192;
            final DoublePointer longPointer = new DoublePointer(longSize);
            assertEquals(longSize, longPointer.capacity());
            DoubleIndexer longIndexer = DoubleIndexer.create(longPointer);
            assertEquals(longIndexer.pointer(), longPointer);
            for (long i = 0; i < 8192; i++) {
                longPointer.put(longSize - i - 1, i);
            }
            for (long i = 0; i < 8192; i++) {
                assertEquals((long) longIndexer.get(longSize - i - 1), i);
            }
            System.out.println("longIndexer[0x" + Long.toHexString(longSize - 8192) + "] = " + longIndexer.get(longSize - 8192));
        } catch (OutOfMemoryError e) {
            System.out.println(e);
        }
    System.out.println();
}

Example 2 with DoubleIndexer

use of org.bytedeco.javacpp.indexer.DoubleIndexer in project javacv by bytedeco.

the class PrincipalComponentAnalysis method principalComponentAnalysis.

// contour is a one dimensional array
private void principalComponentAnalysis(Mat contour, int entry, Mat matrix) throws Exception {
    PCA pca_analysis = null;
    Mat mean = null;
    Mat eigenVector = null;
    Mat eigenValues = null;
    // Construct a buffer used by the pca analysis
    try (Mat data_pts = new Mat(contour.rows(), 2, CV_64FC1);
        Mat placeholder = new Mat();
        Point cntr = new Point()) {
        IntIndexer contourIndexer = contour.createIndexer();
        DoubleIndexer data_idx = data_pts.createIndexer();
        for (int i = 0; i < contour.rows(); i++) {
            data_idx.put(i, 0, contourIndexer.get(i, 0));
            data_idx.put(i, 1, contourIndexer.get(i, 1));
        }
        contourIndexer.release();
        data_idx.release();
        // Perform PrincipalComponentAnalysis analysis
        ArrayList<Point2d> eigen_vecs = new ArrayList(2);
        ArrayList<Double> eigen_val = new ArrayList(2);
        pca_analysis = new PCA(data_pts, placeholder, CV_PCA_DATA_AS_ROW);
        mean = pca_analysis.mean();
        eigenVector = pca_analysis.eigenvectors();
        eigenValues = pca_analysis.eigenvalues();
        DoubleIndexer mean_idx = mean.createIndexer();
        DoubleIndexer eigenVectorIndexer = eigenVector.createIndexer();
        DoubleIndexer eigenValuesIndexer = eigenValues.createIndexer();
        for (int i = 0; i < 2; ++i) {
            eigen_vecs.add(new Point2d(eigenVectorIndexer.get(i, 0), eigenVectorIndexer.get(i, 1)));
            eigen_val.add(eigenValuesIndexer.get(0, i));
        }
        double cntrX = mean_idx.get(0, 0);
        double cntrY = mean_idx.get(0, 1);
        mean_idx.release();
        eigenVectorIndexer.release();
        eigenValuesIndexer.release();
        double x1 = cntrX + 0.02 * (eigen_vecs.get(0).x() * eigen_val.get(0));
        double y1 = cntrY + 0.02 * (eigen_vecs.get(0).y() * eigen_val.get(0));
        double x2 = cntrX - 0.02 * (eigen_vecs.get(1).x() * eigen_val.get(1));
        double y2 = cntrY - 0.02 * (eigen_vecs.get(1).y() * eigen_val.get(1));
        // Draw the principal components, keep accuracy during calculations
        cntr.x((int) Math.rint(cntrX));
        cntr.y((int) Math.rint(cntrY));
        circle(matrix, cntr, 5, new Scalar(255, 0, 255, 0));
        double radian1 = Math.atan2(cntrY - y1, cntrX - x1);
        double radian2 = Math.atan2(cntrY - y2, cntrX - x2);
        double hypotenuse1 = Math.sqrt((cntrY - y1) * (cntrY - y1) + (cntrX - x1) * (cntrX - x1));
        double hypotenuse2 = Math.sqrt((cntrY - y2) * (cntrY - y2) + (cntrX - x2) * (cntrX - x2));
        // Enhance the vector signal by a factor of 2
        double point1x = cntrX - 2 * hypotenuse1 * Math.cos(radian1);
        double point1y = cntrY - 2 * hypotenuse1 * Math.sin(radian1);
        double point2x = cntrX - 2 * hypotenuse2 * Math.cos(radian2);
        double point2y = cntrY - 2 * hypotenuse2 * Math.sin(radian2);
        drawAxis(matrix, radian1, cntr, point1x, point1y, Scalar.BLUE);
        drawAxis(matrix, radian2, cntr, point2x, point2y, Scalar.CYAN);
    } finally {
        if (pca_analysis != null) {
            pca_analysis.deallocate();
        }
        if (mean != null) {
            mean.deallocate();
        }
        if (eigenVector != null) {
            eigenVector.deallocate();
        }
        if (eigenValues != null) {
            eigenValues.deallocate();
        }
    }
}