Examples of net.algart.matrices.scanning.ConnectedObjectScanner

net.algart.matrices.scanning.ConnectedObjectScanner
Connected objects scanner: the class performing scanning and clearing connected objects, "drawn" on some n-dimensional updatable bit matrix.

More precisely, let's consider an AlgART bit matrix ( {@link Matrix}<? extends {@link UpdatableBitArray}>). The connected object is a connected component of the graph, built on the matrix, where unit matrix elements are vertices, and neighbour unit elements are connected by edges. In 2D case, we can consider that the matrix contains images of some objects: unit bits (1) are white pixels, belonging to objects, zero bits (0) are black pixels of the background. Then our term "connected objects" describes the white objects, separated by black space.

We define two kinds of connectivity: {@link ConnectivityType#STRAIGHT_ONLY straight} and {@link ConnectivityType#STRAIGHT_AND_DIAGONAL straight-and-diagonal}. In the first case (straight connectivity), two unit elements with coordinates i₀, i₁, ..., i_n-1 and j₀, j₁, ..., j_n-1 are neighbours if one from the coordinates differs by 1, but all other coordinates are equal:

∑ |i_k−j_k|=1

For 2D matrices, this connectivity kind is also known as "4-connectivity". It the second case (straight-and-diagonal connectivity), two unit elements are neighbours if several (at least one) from their coordinates differ by 1 and all other coordinates are equal:

max (|i_k−j_k|)=1

For 2D matrices, this connectivity kind is also known as "8-connectivity". The connectivity kind is described by {@link ConnectivityType} class.
The instance of this class works with some concrete bit matrix ( {@link Matrix}<? extends {@link UpdatableBitArray}>), named the scanned matrix, and with some concrete connectivity type ( {@link ConnectivityType}). Both the scanned matrix and the connectivity type are specified while creating the instance.

This class allows to visit all elements of the scanner matrix, belonging to one connected object, by its main {@link #clear(ArrayContext,ConnectedObjectScanner.ElementVisitor,long[],boolean) clear} method."Visiting" means that this method calls {@link ConnectedObjectScanner.ElementVisitor#visit(long[],long)}method for every visited element, passing the index of the element in the {@link Matrix#array() underlying array} of the matrix to that method,maybe, together with its coordinates in the matrix (if getting coordinates does not slow down the scanning algorithm).

Besides, the {@link #clear clear} method clears (sets to 0) all visited elements in the bit matrix.But note: actual clearing may be not performed if forceClearing argument of this method is false.

There are following methods allowing to create the instance of this class:
- {@link #getBreadthFirstScanner(Matrix,ConnectivityType)},
- {@link #getDepthFirstScanner(Matrix,ConnectivityType)},
- {@link #getStacklessDepthFirstScanner(Matrix,ConnectivityType)},
- {@link #getUncheckedBreadthFirstScanner(Matrix,ConnectivityType)},
- {@link #getUncheckedDepthFirstScanner(Matrix,ConnectivityType)},
- {@link #getUncheckedStacklessDepthFirstScanner(Matrix,ConnectivityType)},
- {@link #clone()}.
You can switch to another scanned bit matrix with the same dimensions by {@link #matrix(Matrix)} method.
You can use this instance (call its {@link #clear clear} method)many times to scan different connected objects at one matrix. You may use {@link #nextUnitBit(long[])} method to find next connected objectafter scanning and clearing the previous one.

However, you must not use this instance after any modifications in the scanned matrix, performed by an external code. If you modify the matrix, you must create new instance of this class after this.

Note: this class works much faster (in several times) if the scanned matrix is created by {@link SimpleMemoryModel}. So, if the matrix is not created by {@link SimpleMemoryModel} and is not too large,we recommend to create its clone by {@link SimpleMemoryModel} and use this class for the clone.
Note: this class cannot process matrices with too large number of dimensions. The maximal allowed number of dimensions is {@link Matrix#MAX_DIM_COUNT_FOR_SOME_ALGORITHMS}, that is more than enough for most situations.

This class does not use multithreading optimization, unlike {@link Arrays#copy(ArrayContext,UpdatableArray,Array)} and similar methods.In other words, all methods of this class are executed in the current thread.

This class is not thread-safe, but is thread-compatible and can be synchronized manually, if multithread access is necessary. However, usually there are no reasons to use the same instance of this class in different threads: usually there is much better idea to create a separate instance for every thread.

AlgART Laboratory 2007–2014
@author Daniel Alievsky @version 1.2 @since JDK 1.5

                        Matrix<UpdatableBitArray> matrix6x7 = SMM.newBitMatrix(6, 7);
                        Matrix<UpdatableBitArray> matrix6x7Save = SMM.newBitMatrix(6, 7);
                        Matrix<UpdatableBitArray> matrix6x7Work = SMM.newBitMatrix(6, 7);
                        final UpdatableBitArray array6x7 = matrix6x7.array();
                        BitArray thinningXPOrXPYP = getThinningXPOrXPYP(matrix6x7);
                        ConnectedObjectScanner clearer = ConnectedObjectScanner.getBreadthFirstScanner(
                            matrix6x7Work, ConnectivityType.STRAIGHT_AND_DIAGONAL);
                        ConnectedObjectScanner.ElementVisitor drawer = new ConnectedObjectScanner.ElementVisitor() {
                            public void visit(long[] coordinatesInMatrix, long indexInArray) {
                                array6x7.setBit(indexInArray);
                            }
                        };
                        int bitsFrom = ti << (24 - logCpuCount);
                        int bitsTo = bitsFrom + (1 << (24 - logCpuCount));
                        boolean[] centerBitsLocal = new boolean[1 << (24 - logCpuCount)];
                        for (int bits = bitsFrom; bits < bitsTo; bits++) {
                            if (exception.get() != null) {
                                return;
                            }
                            array6x7.fill(false);
                            array6x7.setBit(3 * 6 + 2, true);
                            int bitIndex = 0;
                            boolean hasNeighbour = false;
                            for (int y = 0; y < 5; y++) {
                                for (int x = 0, disp = (y + 1) * 6; x < 5; x++, disp++) {
                                    if (x == 2 && y == 2) {
                                        continue;
                                    }
                                    boolean b = (bits & 1 << bitIndex) != 0;
                                    if (y >= 1 && y <= 3 && x >= 1 && x <= 3) {
                                        hasNeighbour |= b;
                                    }
                                    array6x7.setBit(disp, b);
                                    bitIndex++;
                                }
                            }
                            assert bitIndex == 24;
                            boolean centerStaysUnit = thinningXPOrXPYP.getBit(3 * 6 + 2);
                            centerBitsLocal[bits - bitsFrom] = centerStaysUnit;
                            if (!centerStaysUnit) {
                                if (array6x7.getBit(3 * 6 + 1)) {
                                    leftAlwaysZero.set(false);
                                    leftAlwaysZeroViolation.compareAndSet(null,
                                        matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                    if (array6x7.getBit(2 * 6 + 1)) {
                                        leftOrLeftTopAlwaysZero.set(false);
                                        leftOrLeftTopAlwaysZeroViolation.compareAndSet(null,
                                            matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                    }
                                    if (array6x7.getBit(2 * 6 + 1) || array6x7.getBit(4 * 6 + 1)) {
                                        leftOrLeftPairAlwaysZero.set(false);
                                        leftOrLeftPairAlwaysZeroViolation.compareAndSet(null,
                                            matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                    }
                                }
                                if (!array6x7.getBit(3 * 6 + 3)) {
                                    rightAlwaysUnit.set(false);
                                    rightAlwaysUnitViolation.compareAndSet(null,
                                        matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                    if (hasNeighbour) {
                                        rightAlwaysUnitBesidesIsolatedPixelCase.set(false);
                                        rightAlwaysUnitBesidesIsolatedPixelCaseViolation.compareAndSet(null,
                                            matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));


                                    }
                                }
                                if (hasNeighbour) {
                                    boolean willHaveRightNeighbour = thinningXPOrXPYP.getBit(3 * 6 + 3);
                                    if (!willHaveRightNeighbour) {
                                        rightAlwaysUnitInSkeleton.set(false);
                                        rightAlwaysUnitInSkeletonViolation.compareAndSet(null,
                                            matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                        rightAlwaysUnitInSkeletonViolatingSkeleton.compareAndSet(null,
                                            matrix6x7.matrix(thinningXPOrXPYP.updatableClone(Arrays.SMM)));
                                        boolean hasRightTopNeighbour = array6x7.getBit(2 * 6 + 3);
                                        boolean hasRightBottomNeighbour = array6x7.getBit(4 * 6 + 3);
                                        boolean willHaveRightTopNeighbour = true;
                                        for (int top3Bits = 0; top3Bits < 8; top3Bits++) {
                                            for (int x = 0; x < 3; x++) {
                                                array6x7.setBit(2 + x, (top3Bits & 1 << x) != 0);
                                            }
                                            if (!thinningXPOrXPYP.getBit(2 * 6 + 3)) {
                                                willHaveRightTopNeighbour = false;
                                                break; // save "bad" configuration at finish
                                            }
                                        }
                                        boolean willHaveRightBottomNeighbour = true;
                                        for (int bottom3Bits = 0; bottom3Bits < 8; bottom3Bits++) {
                                            for (int x = 0; x < 3; x++) {
                                                array6x7.setBit(6 * 6 + 2 + x, (bottom3Bits & 1 << x) != 0);
                                            }
                                            if (!thinningXPOrXPYP.getBit(4 * 6 + 3)) {
                                                willHaveRightBottomNeighbour = false;
                                                break; // save "bad" configuration at finish
                                            }
                                        }
                                        if (willHaveRightTopNeighbour && !hasRightTopNeighbour)
                                            throw new AssertionError(String.format(
                                                "ZERO BECOMES UNIT at (3,2):%n%s%nis transformed to%n%s",
                                                AnalyseSkeletonConfigurations.bitMatrixToString(
                                                    matrix6x7, 0, 1, 4, 5, 2, 3, "    ", true),
                                                AnalyseSkeletonConfigurations.bitMatrixToString(matrix6x7.matrix(
                                                    thinningXPOrXPYP), 0, 1, 4, 5, 2, 3, "    ", true)));
                                        if (willHaveRightBottomNeighbour && !hasRightBottomNeighbour)
                                            throw new AssertionError(String.format(
                                                "ZERO BECOMES UNIT at (3,4):%n%s%nis transformed to%n%s",
                                                AnalyseSkeletonConfigurations.bitMatrixToString(
                                                    matrix6x7, 0, 1, 4, 5, 2, 3, "    ", true),
                                                AnalyseSkeletonConfigurations.bitMatrixToString(matrix6x7.matrix(
                                                    thinningXPOrXPYP), 0, 1, 4, 5, 2, 3, "    ", true)));
                                        // the assertions above are completely verified by VerifySkeletonSymmetry
                                        if (!(willHaveRightTopNeighbour && hasRightBottomNeighbour)) {
                                            rightOrRightTopAlwaysUnitInSkeleton.set(false);
                                            rightOrRightTopAlwaysUnitInSkeletonViolation.compareAndSet(null,
                                                matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                            rightOrRightTopAlwaysUnitInSkeletonViolatingSkeleton.compareAndSet(null,
                                                matrix6x7.matrix(thinningXPOrXPYP.updatableClone(Arrays.SMM)));
                                        }
                                        if (!((willHaveRightTopNeighbour && hasRightBottomNeighbour) ||
                                            (willHaveRightBottomNeighbour && hasRightTopNeighbour)))
                                        {
                                            rightInSkeletonOrRightPairAlwaysUnit.set(false);
                                            rightInSkeletonOrRightPairAlwaysUnitViolation.compareAndSet(null,
                                                matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                            rightInSkeletonOrRightPairAlwaysUnitViolatingSkeleton.compareAndSet(null,
                                                matrix6x7.matrix(thinningXPOrXPYP.updatableClone(Arrays.SMM)));
                                        }
                                        boolean willHaveBottomNeighbour = true;
                                        if (!willHaveRightTopNeighbour && !willHaveRightBottomNeighbour) {
                                            for (int bottom3Bits = 0; bottom3Bits < 8; bottom3Bits++) {
                                                for (int x = 0; x < 3; x++) {
                                                    array6x7.setBit(6 * 6 + 1 + x, (bottom3Bits & 1 << x) != 0);
                                                }
                                                if (!thinningXPOrXPYP.getBit(4 * 6 + 2)) {
                                                    willHaveBottomNeighbour = false;
                                                    break; // save "bad" configuration at finish
                                                }
                                            }
                                            if (!willHaveBottomNeighbour) {
                                                rightLocality.set(false);
                                                rightLocalityViolation.compareAndSet(null,
                                                    matrix6x7.matrix(array6x7.updatableClone(Arrays.SMM)));
                                                rightLocalityViolatingSkeleton.compareAndSet(null,
                                                    matrix6x7.matrix(thinningXPOrXPYP.updatableClone(Arrays.SMM)));
                                            }
                                        }
                                    }
                                }
                                matrix6x7Save.array().copy(array6x7);
                                matrix6x7Work.array().copy(array6x7);
                                array6x7.fill(false);
                                clearer.clear(null, drawer, 2, 3);
//                            System.out.printf("%n%s%s",
//                                AnalyseSkeletonConfigurations.bitMatrixToString(matrix6x7Save,
//                                    0, 1, 4, 5, 2, 3, "    ", true),
//                                AnalyseSkeletonConfigurations.bitMatrixToString(matrix6x7,
//                                    0, 1, 4, 5, 2, 3, ">   ", true));

View Full Code Here

        final UpdatableBitArray array8xN = matrix8xN.array();
        final UpdatableBitArray save3x3Array8x8 = array8x8.updatableClone(Arrays.SMM);
        final UpdatableBitArray save5x5Array8x8 = array8x8.updatableClone(Arrays.SMM);
        final ThinningSkeleton skeleton8x8 = getSkeleton(skeletonType, diagonal, topological, matrix8x8);
        final ThinningSkeleton skeleton8xN = getSkeleton(skeletonType, diagonal, topological, matrix8xN);
        ConnectedObjectScanner scanner8x8OfWork = ConnectedObjectScanner.getBreadthFirstScanner(
            matrix8x8Work, ConnectivityType.STRAIGHT_AND_DIAGONAL);


//        for (int bitsA = 0; bitsA < NUMBER_OF_BITS_A; bitsA++) {
//            if (bitsAForConstructingLargeConfigurations.get(bitsA)) {
//                System.out.println(bitsA);

View Full Code Here

TOP

Related Classes of net.algart.matrices.scanning.ConnectedObjectScanner

net.algart.matrices.skeletons.demo.AnalyseSkeletonConfigurations

net.algart.matrices.skeletons.demo.VerifySkeletonConnectivity

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.