@cloudbase/framework-plugin-low-code 0.4.45 → 0.5.1

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

@@ -1,78 +0,0 @@
-/*
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,201 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,71 +0,0 @@
-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

@@ -1,302 +0,0 @@
-/*
- * 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