@cloudbase/framework-plugin-low-code 0.4.42-alpha.2 → 0.4.45

package/template/node_modules/@zxing/library/es2015/core/common/detector/MathUtils.js

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*namespace com.google.zxing.common.detector {*/
+/**
+ * General math-related and numeric utility functions.
+ */
+export default class MathUtils {
+    constructor() { }
+    /**
+     * Ends up being a bit faster than {@link Math#round(float)}. This merely rounds its
+     * argument to the nearest int, where x.5 rounds up to x+1. Semantics of this shortcut
+     * differ slightly from {@link Math#round(float)} in that half rounds down for negative
+     * values. -2.5 rounds to -3, not -2. For purposes here it makes no difference.
+     *
+     * @param d real value to round
+     * @return nearest {@code int}
+     */
+    static round(d /*float*/) {
+        if (NaN === d)
+            return 0;
+        if (d <= Number.MIN_SAFE_INTEGER)
+            return Number.MIN_SAFE_INTEGER;
+        if (d >= Number.MAX_SAFE_INTEGER)
+            return Number.MAX_SAFE_INTEGER;
+        return /*(int) */ (d + (d < 0.0 ? -0.5 : 0.5)) | 0;
+    }
+    // TYPESCRIPTPORT: maybe remove round method and call directly Math.round, it looks like it doesn't make sense for js
+    /**
+     * @param aX point A x coordinate
+     * @param aY point A y coordinate
+     * @param bX point B x coordinate
+     * @param bY point B y coordinate
+     * @return Euclidean distance between points A and B
+     */
+    static distance(aX /*float|int*/, aY /*float|int*/, bX /*float|int*/, bY /*float|int*/) {
+        const xDiff = aX - bX;
+        const yDiff = aY - bY;
+        return /*(float) */ Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+    }
+    /**
+     * @param aX point A x coordinate
+     * @param aY point A y coordinate
+     * @param bX point B x coordinate
+     * @param bY point B y coordinate
+     * @return Euclidean distance between points A and B
+     */
+    // public static distance(aX: number /*int*/, aY: number /*int*/, bX: number /*int*/, bY: number /*int*/): float {
+    //   const xDiff = aX - bX
+    //   const yDiff = aY - bY
+    //   return (float) Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+    // }
+    /**
+     * @param array values to sum
+     * @return sum of values in array
+     */
+    static sum(array) {
+        let count = 0;
+        for (let i = 0, length = array.length; i !== length; i++) {
+            const a = array[i];
+            count += a;
+        }
+        return count;
+    }
+}
+//# sourceMappingURL=MathUtils.js.map

package/template/node_modules/@zxing/library/es2015/core/common/detector/MathUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathUtils.js","sourceRoot":"","sources":["../../../../../src/core/common/detector/MathUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,gDAAgD;AAEhD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,SAAS;IAE5B,gBAAwB,CAAC;IAEzB;;;;;;;;OAQG;IACI,MAAM,CAAC,KAAK,CAAC,CAAS,CAAA,SAAS;QACpC,IAAI,GAAG,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,MAAM,CAAC,gBAAgB;YAAE,OAAO,MAAM,CAAC,gBAAgB,CAAC;QACjE,IAAI,CAAC,IAAI,MAAM,CAAC,gBAAgB;YAAE,OAAO,MAAM,CAAC,gBAAgB,CAAC;QACjE,OAAO,UAAU,CAAA,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;IACpD,CAAC;IACD,qHAAqH;IAErH;;;;;;OAMG;IACI,MAAM,CAAC,QAAQ,CAAC,EAAU,CAAA,aAAa,EAAE,EAAU,CAAA,aAAa,EAAE,EAAU,CAAA,aAAa,EAAE,EAAU,CAAA,aAAa;QACvH,MAAM,KAAK,GAAG,EAAE,GAAG,EAAE,CAAC;QACtB,MAAM,KAAK,GAAG,EAAE,GAAG,EAAE,CAAC;QACtB,OAAO,YAAY,CAAA,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;OAMG;IACH,kHAAkH;IAClH,0BAA0B;IAC1B,0BAA0B;IAC1B,6DAA6D;IAC7D,IAAI;IAEJ;;;OAGG;IACI,MAAM,CAAC,GAAG,CAAC,KAAiB;QACjC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,EAAE,CAAC,EAAE,EAAE;YACxD,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACnB,KAAK,IAAI,CAAC,CAAC;SACZ;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CAEF"}

package/template/node_modules/@zxing/library/es2015/core/common/detector/MonochromeRectangleDetector.js

@@ -0,0 +1,201 @@
+"use strict";
+// /*
+//  * Copyright 2009 ZXing authors
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *      http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+// /*namespace com.google.zxing.common.detector {*/
+// import ResultPoint from '../../ResultPoint'
+// import BitMatrix from '../BitMatrix'
+// /**
+//  * <p>A somewhat generic detector that looks for a barcode-like rectangular region within an image.
+//  * It looks within a mostly white region of an image for a region of black and white, but mostly
+//  * black. It returns the four corners of the region, as best it can determine.</p>
+//  *
+//  * @author Sean Owen
+//  * @deprecated without replacement since 3.3.0
+//  */
+// @Deprecated
+// export default class MonochromeRectangleDetector {
+//   private 32: static final int MAX_MODULES =
+//   private image: BitMatrix
+//   public constructor(image: BitMatrix) {
+//     this.image = image
+//   }
+//   /**
+//    * <p>Detects a rectangular region of black and white -- mostly black -- with a region of mostly
+//    * white, in an image.</p>
+//    *
+//    * @return {@link ResultPoint}[] describing the corners of the rectangular region. The first and
+//    *  last points are opposed on the diagonal, as are the second and third. The first point will be
+//    *  the topmost point and the last, the bottommost. The second point will be leftmost and the
+//    *  third, the rightmost
+//    * @throws NotFoundException if no Data Matrix Code can be found
+//    */
+//   public detect(): ResultPoInt32Array /*throws NotFoundException*/ {
+//     height: number /*int*/ = image.getHeight();
+//     width: number /*int*/ = image.getWidth();
+//     const halfHeight = height / 2
+//     const halfWidth = width / 2
+//     const deltaY = Math.max(1, height / (MAX_MODULES * 8));
+//     const deltaX = Math.max(1, width / (MAX_MODULES * 8));
+//     const top = 0
+//     const bottom = height
+//     const left = 0
+//     const right = width
+//     ResultPoint pointA = findCornerFromCenter(halfWidth, 0, left, right,
+//         halfHeight, -deltaY, top, bottom, halfWidth / 2)
+//     top = (int) pointA.getY() - 1
+//     ResultPoint pointB = findCornerFromCenter(halfWidth, -deltaX, left, right,
+//         halfHeight, 0, top, bottom, halfHeight / 2)
+//     left = (int) pointB.getX() - 1
+//     ResultPoint pointC = findCornerFromCenter(halfWidth, deltaX, left, right,
+//         halfHeight, 0, top, bottom, halfHeight / 2)
+//     right = (int) pointC.getX() + 1
+//     ResultPoint pointD = findCornerFromCenter(halfWidth, 0, left, right,
+//         halfHeight, deltaY, top, bottom, halfWidth / 2)
+//     bottom = (int) pointD.getY() + 1
+//     // Go try to find point A again with better information -- might have been off at first.
+//     pointA = findCornerFromCenter(halfWidth, 0, left, right,
+//         halfHeight, -deltaY, top, bottom, halfWidth / 4)
+//     return new ResultPoInt32Array { pointA, pointB, pointC, pointD }
+//   }
+//   /**
+//    * Attempts to locate a corner of the barcode by scanning up, down, left or right from a center
+//    * point which should be within the barcode.
+//    *
+//    * @param centerX center's x component (horizontal)
+//    * @param deltaX same as deltaY but change in x per step instead
+//    * @param left minimum value of x
+//    * @param right maximum value of x
+//    * @param centerY center's y component (vertical)
+//    * @param deltaY change in y per step. If scanning up this is negative; down, positive;
+//    *  left or right, 0
+//    * @param top minimum value of y to search through (meaningless when di == 0)
+//    * @param bottom maximum value of y
+//    * @param maxWhiteRun maximum run of white pixels that can still be considered to be within
+//    *  the barcode
+//    * @return a {@link ResultPoint} encapsulating the corner that was found
+//    * @throws NotFoundException if such a point cannot be found
+//    */
+//   private ResultPoint findCornerFromCenter(centerX: number /*int*/,
+//                                            deltaX: number /*int*/,
+//                                            left: number /*int*/,
+//                                            right: number /*int*/,
+//                                            centerY: number /*int*/,
+//                                            deltaY: number /*int*/,
+//                                            top: number /*int*/,
+//                                            bottom: number /*int*/,
+//                                            maxWhiteRun: number /*int*/) /*throws NotFoundException*/ {
+//     const lastRange: Int32Array = null
+//     for (let y = centerY, x = centerX
+//          y < bottom && y >= top && x < right && x >= left
+//          y += deltaY, x += deltaX) {
+//       const range: Int32Array
+//       if (deltaX == 0) {
+//         // horizontal slices, up and down
+//         range = blackWhiteRange(y, maxWhiteRun, left, right, true)
+//       } else {
+//         // vertical slices, left and right
+//         range = blackWhiteRange(x, maxWhiteRun, top, bottom, false)
+//       }
+//       if (range == null) {
+//         if (lastRange == null) {
+//           throw NotFoundException.getNotFoundInstance()
+//         }
+//         // lastRange was found
+//         if (deltaX == 0) {
+//           const lastY = y - deltaY
+//           if (lastRange[0] < centerX) {
+//             if (lastRange[1] > centerX) {
+//               // straddle, choose one or the other based on direction
+//               return new ResultPoint(lastRange[deltaY > 0 ? 0 : 1], lastY)
+//             }
+//             return new ResultPoint(lastRange[0], lastY)
+//           } else {
+//             return new ResultPoint(lastRange[1], lastY)
+//           }
+//         } else {
+//           const lastX = x - deltaX
+//           if (lastRange[0] < centerY) {
+//             if (lastRange[1] > centerY) {
+//               return new ResultPoint(lastX, lastRange[deltaX < 0 ? 0 : 1])
+//             }
+//             return new ResultPoint(lastX, lastRange[0])
+//           } else {
+//             return new ResultPoint(lastX, lastRange[1])
+//           }
+//         }
+//       }
+//       lastRange = range
+//     }
+//     throw NotFoundException.getNotFoundInstance()
+//   }
+//   /**
+//    * Computes the start and end of a region of pixels, either horizontally or vertically, that could
+//    * be part of a Data Matrix barcode.
+//    *
+//    * @param fixedDimension if scanning horizontally, this is the row (the fixed vertical location)
+//    *  where we are scanning. If scanning vertically it's the column, the fixed horizontal location
+//    * @param maxWhiteRun largest run of white pixels that can still be considered part of the
+//    *  barcode region
+//    * @param minDim minimum pixel location, horizontally or vertically, to consider
+//    * @param maxDim maximum pixel location, horizontally or vertically, to consider
+//    * @param horizontal if true, we're scanning left-right, instead of up-down
+//    * @return const with: Int32Array start and end of found range, or null if no such range is found
+//    *  (e.g. only white was found)
+//    */
+//   private const blackWhiteRange: Int32Array(fixedDimension: number /*int*/, maxWhiteRun: number /*int*/, minDim: number /*int*/, maxDim: number /*int*/, boolean horizontal) {
+//     const center = (minDim + maxDim) / 2
+//     // Scan left/up first
+//     const start = center
+//     while (start >= minDim) {
+//       if (horizontal ? image.get(start, fixedDimension) : image.get(fixedDimension, start)) {
+//         start--
+//       } else {
+//         const whiteRunStart = start
+//         do {
+//           start--
+//         } while (start >= minDim && !(horizontal ? image.get(start, fixedDimension) :
+//             image.get(fixedDimension, start)))
+//         const whiteRunSize = whiteRunStart - start
+//         if (start < minDim || whiteRunSize > maxWhiteRun) {
+//           start = whiteRunStart
+//           break
+//         }
+//       }
+//     }
+//     start++
+//     // Then try right/down
+//     const end = center
+//     while (end < maxDim) {
+//       if (horizontal ? image.get(end, fixedDimension) : image.get(fixedDimension, end)) {
+//         end++
+//       } else {
+//         const whiteRunStart = end
+//         do {
+//           end++
+//         } while (end < maxDim && !(horizontal ? image.get(end, fixedDimension) :
+//             image.get(fixedDimension, end)))
+//         const whiteRunSize = end - whiteRunStart
+//         if (end >= maxDim || whiteRunSize > maxWhiteRun) {
+//           end = whiteRunStart
+//           break
+//         }
+//       }
+//     }
+//     end--
+//     return end > start ? new Int32Array{start, end} : null
+//   }
+// }
+//# sourceMappingURL=MonochromeRectangleDetector.js.map

package/template/node_modules/@zxing/library/es2015/core/common/detector/MonochromeRectangleDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MonochromeRectangleDetector.js","sourceRoot":"","sources":["../../../../../src/core/common/detector/MonochromeRectangleDetector.ts"],"names":[],"mappings":"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"}

package/template/node_modules/@zxing/library/es2015/core/common/detector/WhiteRectangleDetector.d.ts

@@ -0,0 +1,71 @@
+import ResultPoint from '../../ResultPoint';
+import BitMatrix from '../BitMatrix';
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ * </p>
+ *
+ * @author David Olivier
+ */
+export default class WhiteRectangleDetector {
+    private image;
+    private static INIT_SIZE;
+    private static CORR;
+    private height;
+    private width;
+    private leftInit;
+    private rightInit;
+    private downInit;
+    private upInit;
+    /**
+     * @param image barcode image to find a rectangle in
+     * @param initSize initial size of search area around center
+     * @param x x position of search center
+     * @param y y position of search center
+     * @throws NotFoundException if image is too small to accommodate {@code initSize}
+     */
+    constructor(image: BitMatrix, initSize?: number, x?: number, y?: number);
+    /**
+     * <p>
+     * Detects a candidate barcode-like rectangular region within an image. It
+     * starts around the center of the image, increases the size of the candidate
+     * region until it finds a white rectangular region.
+     * </p>
+     *
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     * @throws NotFoundException if no Data Matrix Code can be found
+     */
+    detect(): Array<ResultPoint>;
+    private getBlackPointOnSegment;
+    /**
+     * recenters the points of a constant distance towards the center
+     *
+     * @param y bottom most point
+     * @param z left most point
+     * @param x right most point
+     * @param t top most point
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     */
+    private centerEdges;
+    /**
+     * Determines whether a segment contains a black point
+     *
+     * @param a          min value of the scanned coordinate
+     * @param b          max value of the scanned coordinate
+     * @param fixed      value of fixed coordinate
+     * @param horizontal set to true if scan must be horizontal, false if vertical
+     * @return true if a black point has been found, else false.
+     */
+    private containsBlackPoint;
+}

package/template/node_modules/@zxing/library/es2015/core/common/detector/WhiteRectangleDetector.js

@@ -0,0 +1,302 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*namespace com.google.zxing.common.detector {*/
+import ResultPoint from '../../ResultPoint';
+import MathUtils from './MathUtils';
+import NotFoundException from '../../NotFoundException';
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ * </p>
+ *
+ * @author David Olivier
+ */
+export default class WhiteRectangleDetector {
+    // public constructor(private image: BitMatrix) /*throws NotFoundException*/ {
+    //   this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2)
+    // }
+    /**
+     * @param image barcode image to find a rectangle in
+     * @param initSize initial size of search area around center
+     * @param x x position of search center
+     * @param y y position of search center
+     * @throws NotFoundException if image is too small to accommodate {@code initSize}
+     */
+    constructor(image, initSize /*int*/, x /*int*/, y /*int*/) {
+        this.image = image;
+        this.height = image.getHeight();
+        this.width = image.getWidth();
+        if (undefined === initSize || null === initSize) {
+            initSize = WhiteRectangleDetector.INIT_SIZE;
+        }
+        if (undefined === x || null === x) {
+            x = image.getWidth() / 2 | 0;
+        }
+        if (undefined === y || null === y) {
+            y = image.getHeight() / 2 | 0;
+        }
+        const halfsize = initSize / 2 | 0;
+        this.leftInit = x - halfsize;
+        this.rightInit = x + halfsize;
+        this.upInit = y - halfsize;
+        this.downInit = y + halfsize;
+        if (this.upInit < 0 || this.leftInit < 0 || this.downInit >= this.height || this.rightInit >= this.width) {
+            throw new NotFoundException();
+        }
+    }
+    /**
+     * <p>
+     * Detects a candidate barcode-like rectangular region within an image. It
+     * starts around the center of the image, increases the size of the candidate
+     * region until it finds a white rectangular region.
+     * </p>
+     *
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     * @throws NotFoundException if no Data Matrix Code can be found
+     */
+    detect() {
+        let left = this.leftInit;
+        let right = this.rightInit;
+        let up = this.upInit;
+        let down = this.downInit;
+        let sizeExceeded = false;
+        let aBlackPointFoundOnBorder = true;
+        let atLeastOneBlackPointFoundOnBorder = false;
+        let atLeastOneBlackPointFoundOnRight = false;
+        let atLeastOneBlackPointFoundOnBottom = false;
+        let atLeastOneBlackPointFoundOnLeft = false;
+        let atLeastOneBlackPointFoundOnTop = false;
+        const width = this.width;
+        const height = this.height;
+        while (aBlackPointFoundOnBorder) {
+            aBlackPointFoundOnBorder = false;
+            // .....
+            // .   |
+            // .....
+            let rightBorderNotWhite = true;
+            while ((rightBorderNotWhite || !atLeastOneBlackPointFoundOnRight) && right < width) {
+                rightBorderNotWhite = this.containsBlackPoint(up, down, right, false);
+                if (rightBorderNotWhite) {
+                    right++;
+                    aBlackPointFoundOnBorder = true;
+                    atLeastOneBlackPointFoundOnRight = true;
+                }
+                else if (!atLeastOneBlackPointFoundOnRight) {
+                    right++;
+                }
+            }
+            if (right >= width) {
+                sizeExceeded = true;
+                break;
+            }
+            // .....
+            // .   .
+            // .___.
+            let bottomBorderNotWhite = true;
+            while ((bottomBorderNotWhite || !atLeastOneBlackPointFoundOnBottom) && down < height) {
+                bottomBorderNotWhite = this.containsBlackPoint(left, right, down, true);
+                if (bottomBorderNotWhite) {
+                    down++;
+                    aBlackPointFoundOnBorder = true;
+                    atLeastOneBlackPointFoundOnBottom = true;
+                }
+                else if (!atLeastOneBlackPointFoundOnBottom) {
+                    down++;
+                }
+            }
+            if (down >= height) {
+                sizeExceeded = true;
+                break;
+            }
+            // .....
+            // |   .
+            // .....
+            let leftBorderNotWhite = true;
+            while ((leftBorderNotWhite || !atLeastOneBlackPointFoundOnLeft) && left >= 0) {
+                leftBorderNotWhite = this.containsBlackPoint(up, down, left, false);
+                if (leftBorderNotWhite) {
+                    left--;
+                    aBlackPointFoundOnBorder = true;
+                    atLeastOneBlackPointFoundOnLeft = true;
+                }
+                else if (!atLeastOneBlackPointFoundOnLeft) {
+                    left--;
+                }
+            }
+            if (left < 0) {
+                sizeExceeded = true;
+                break;
+            }
+            // .___.
+            // .   .
+            // .....
+            let topBorderNotWhite = true;
+            while ((topBorderNotWhite || !atLeastOneBlackPointFoundOnTop) && up >= 0) {
+                topBorderNotWhite = this.containsBlackPoint(left, right, up, true);
+                if (topBorderNotWhite) {
+                    up--;
+                    aBlackPointFoundOnBorder = true;
+                    atLeastOneBlackPointFoundOnTop = true;
+                }
+                else if (!atLeastOneBlackPointFoundOnTop) {
+                    up--;
+                }
+            }
+            if (up < 0) {
+                sizeExceeded = true;
+                break;
+            }
+            if (aBlackPointFoundOnBorder) {
+                atLeastOneBlackPointFoundOnBorder = true;
+            }
+        }
+        if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {
+            const maxSize = right - left;
+            let z = null;
+            for (let i = 1; z === null && i < maxSize; i++) {
+                z = this.getBlackPointOnSegment(left, down - i, left + i, down);
+            }
+            if (z == null) {
+                throw new NotFoundException();
+            }
+            let t = null;
+            // go down right
+            for (let i = 1; t === null && i < maxSize; i++) {
+                t = this.getBlackPointOnSegment(left, up + i, left + i, up);
+            }
+            if (t == null) {
+                throw new NotFoundException();
+            }
+            let x = null;
+            // go down left
+            for (let i = 1; x === null && i < maxSize; i++) {
+                x = this.getBlackPointOnSegment(right, up + i, right - i, up);
+            }
+            if (x == null) {
+                throw new NotFoundException();
+            }
+            let y = null;
+            // go up left
+            for (let i = 1; y === null && i < maxSize; i++) {
+                y = this.getBlackPointOnSegment(right, down - i, right - i, down);
+            }
+            if (y == null) {
+                throw new NotFoundException();
+            }
+            return this.centerEdges(y, z, x, t);
+        }
+        else {
+            throw new NotFoundException();
+        }
+    }
+    getBlackPointOnSegment(aX /*float*/, aY /*float*/, bX /*float*/, bY /*float*/) {
+        const dist = MathUtils.round(MathUtils.distance(aX, aY, bX, bY));
+        const xStep = (bX - aX) / dist;
+        const yStep = (bY - aY) / dist;
+        const image = this.image;
+        for (let i = 0; i < dist; i++) {
+            const x = MathUtils.round(aX + i * xStep);
+            const y = MathUtils.round(aY + i * yStep);
+            if (image.get(x, y)) {
+                return new ResultPoint(x, y);
+            }
+        }
+        return null;
+    }
+    /**
+     * recenters the points of a constant distance towards the center
+     *
+     * @param y bottom most point
+     * @param z left most point
+     * @param x right most point
+     * @param t top most point
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     */
+    centerEdges(y, z, x, t) {
+        //
+        //       t            t
+        //  z                      x
+        //        x    OR    z
+        //   y                    y
+        //
+        const yi = y.getX();
+        const yj = y.getY();
+        const zi = z.getX();
+        const zj = z.getY();
+        const xi = x.getX();
+        const xj = x.getY();
+        const ti = t.getX();
+        const tj = t.getY();
+        const CORR = WhiteRectangleDetector.CORR;
+        if (yi < this.width / 2.0) {
+            return [
+                new ResultPoint(ti - CORR, tj + CORR),
+                new ResultPoint(zi + CORR, zj + CORR),
+                new ResultPoint(xi - CORR, xj - CORR),
+                new ResultPoint(yi + CORR, yj - CORR)
+            ];
+        }
+        else {
+            return [
+                new ResultPoint(ti + CORR, tj + CORR),
+                new ResultPoint(zi + CORR, zj - CORR),
+                new ResultPoint(xi - CORR, xj + CORR),
+                new ResultPoint(yi - CORR, yj - CORR)
+            ];
+        }
+    }
+    /**
+     * Determines whether a segment contains a black point
+     *
+     * @param a          min value of the scanned coordinate
+     * @param b          max value of the scanned coordinate
+     * @param fixed      value of fixed coordinate
+     * @param horizontal set to true if scan must be horizontal, false if vertical
+     * @return true if a black point has been found, else false.
+     */
+    containsBlackPoint(a /*int*/, b /*int*/, fixed /*int*/, horizontal) {
+        const image = this.image;
+        if (horizontal) {
+            for (let x = a; x <= b; x++) {
+                if (image.get(x, fixed)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            for (let y = a; y <= b; y++) {
+                if (image.get(fixed, y)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+WhiteRectangleDetector.INIT_SIZE = 10;
+WhiteRectangleDetector.CORR = 1;
+//# sourceMappingURL=WhiteRectangleDetector.js.map