添加网站文件

vendor/khanamiryan/qrcode-detector-decoder/lib/common/detector/MathUtils.php

@@ -0,0 +1,46 @@
+<?php
+/*
+* 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 Zxing\Common\Detector;
+
+final class MathUtils {
+
+    private function __construct() {
+
+    }
+
+    /**
+     * 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}
+     */
+    public static function round($d) {
+        return (int) ($d + ($d < 0.0 ? -0.5 : 0.5));
+    }
+
+    public static function distance($aX, $aY, $bX, $bY) {
+        $xDiff = $aX - $bX;
+        $yDiff = $aY - $bY;
+        return (float) sqrt($xDiff * $xDiff + $yDiff * $yDiff);
+    }
+
+
+}

vendor/khanamiryan/qrcode-detector-decoder/lib/common/detector/MonochromeRectangleDetector.php

@@ -0,0 +1,225 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: Ashot
+ * Date: 3/24/15
+ * Time: 21:23
+ */
+namespace  Zxing\Common\Detector;
+
+use \Zxing\NotFoundException;
+use \Zxing\ResultPoint;
+use \Zxing\BitMatrix;
+
+/*
+ *
+ *
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+
+ */
+//require_once('./lib/NotFoundException.php');
+//require_once('./lib/ResultPoint.php');
+//require_once('./lib/common/BitMatrix.php');
+
+
+/**
+ * <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
+ * @port Ashot Khanamiryan
+ */
+class MonochromeRectangleDetector {
+    private static $MAX_MODULES = 32;
+    private  $image;
+    function __construct($image){
+        $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 function detect(){
+
+        $height = $this->image->getHeight();
+        $width = $this->image->getWidth();
+        $halfHeight = $height / 2;
+        $halfWidth = $width / 2;
+
+        $deltaY = max(1, $height / (self::$MAX_MODULES * 8));
+        $deltaX = max(1, $width / (self::$MAX_MODULES * 8));
+
+
+        $top = 0;
+        $bottom = $height;
+        $left = 0;
+        $right = $width;
+        $pointA = $this->findCornerFromCenter($halfWidth, 0, $left, $right,
+                $halfHeight, -$deltaY, $top, $bottom, $halfWidth / 2);
+    $top = (int) $pointA->getY() - 1;
+    $pointB = $this->findCornerFromCenter($halfWidth, -$deltaX, $left,$right,
+                $halfHeight, 0, $top, $bottom, $halfHeight / 2);
+    $left = (int) $pointB->getX() - 1;
+    $pointC = $this->findCornerFromCenter($halfWidth, $deltaX, $left, $right,
+                $halfHeight, 0, $top, $bottom, $halfHeight / 2);
+    $right = (int) $pointC->getX() + 1;
+    $pointD = $this->findCornerFromCenter($halfWidth, 0, $left, $right,
+                $halfHeight, $deltaY, $top, $bottom, $halfWidth / 2);
+    $bottom = (int) $pointD->getY() + 1;
+
+    // Go try to find po$A again with better information -- might have been off at first.
+    $pointA = $this->findCornerFromCenter($halfWidth, 0, $left, $right,
+        $halfHeight, -$deltaY, $top, $bottom, $halfWidth / 4);
+
+    return new ResultPoint( $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 com.google.zxing.ResultPoint} encapsulating the corner that was found
+     * @throws NotFoundException if such a point cannot be found
+     */
+    private function  findCornerFromCenter($centerX,
+                                           $deltaX,
+                                           $left,
+                                           $right,
+                                           $centerY,
+                                           $deltaY,
+                                           $top,
+                                           $bottom,
+                                           $maxWhiteRun){
+        $lastRange = null;
+        for ($y = $centerY, $x = $centerX;
+             $y < $bottom && $y >= $top && $x < $right && $x >= $left;
+        $y += $deltaY, $x += $deltaX) {
+            $range = 0;
+      if ($deltaX == 0) {
+          // horizontal slices, up and down
+          $range = $this->blackWhiteRange($y, $maxWhiteRun, $left, $right, true);
+      } else {
+          // vertical slices, left and right
+          $range = $this->blackWhiteRange($x, $maxWhiteRun, $top, $bottom, false);
+      }
+      if ($range == null) {
+          if ($lastRange == null) {
+              throw NotFoundException::getNotFoundInstance();
+          }
+          // lastRange was found
+          if ($deltaX == 0) {
+              $lastY = $y - $deltaY;
+          if ($lastRange[0] < $centerX) {
+                  if ($lastRange[1] > $centerX) {
+                      // straddle, choose one or the other based on direction
+                      return new ResultPoint($deltaY > 0 ? $lastRange[0] : $lastRange[1], $lastY);
+            }
+            return new ResultPoint($lastRange[0], $lastY);
+          } else {
+                  return new ResultPoint($lastRange[1], $lastY);
+          }
+        } else {
+              $lastX = $x - $deltaX;
+          if ($lastRange[0] < $centerY) {
+                  if ($lastRange[1] > $centerY) {
+                      return new ResultPoint($lastX, $deltaX < 0 ? $lastRange[0] : $lastRange[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 int[] with start and end of found range, or null if no such range is found
+     *  (e.g. only white was found)
+     */
+
+    private function blackWhiteRange($fixedDimension, $maxWhiteRun, $minDim, $maxDim, $horizontal){
+        $center = ($minDim + $maxDim) / 2;
+
+    // Scan left/up first
+    $start = $center;
+    while ($start >= $minDim) {
+        if ($horizontal ? $this->image->get($start, $fixedDimension) : $this->image->get($fixedDimension, $start)) {
+            $start--;
+        } else {
+            $whiteRunStart = $start;
+        do {
+           $start--;
+        } while ($start >= $minDim && !($horizontal ? $this->image->get($start, $fixedDimension) :
+                $this->image->get($fixedDimension, $start)));
+        $whiteRunSize = $whiteRunStart - $start;
+        if ($start < $minDim || $whiteRunSize > $maxWhiteRun) {
+            $start = $whiteRunStart;
+            break;
+        }
+      }
+    }
+    $start++;
+
+    // Then try right/down
+    $end = $center;
+    while ($end < $maxDim) {
+        if ($horizontal ? $this->image->get($end, $fixedDimension) : $this->image->get($fixedDimension, $end)) {
+            $end++;
+        } else {
+            $whiteRunStart = $end;
+        do {
+            $end++;
+        } while ($end < $maxDim && !($horizontal ? $this->image->get($end, $fixedDimension) :
+                $this->image->get($fixedDimension, $end)));
+        $whiteRunSize = $end - $whiteRunStart;
+        if ($end >= $maxDim || $whiteRunSize > $maxWhiteRun) {
+            $end = $whiteRunStart;
+            break;
+        }
+      }
+    }
+    $end--;
+
+    return $end > $start ? array($start, $end) : null;
+    }
+}