mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 12:22:34 +00:00
multi migrated errors
This commit is contained in:
Henry
@@ -1,117 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi;
|
||||
|
||||
import com.google.zxing.BinaryBitmap;
|
||||
import com.google.zxing.ChecksumException;
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.FormatException;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.Reader;
|
||||
import com.google.zxing.Result;
|
||||
import com.google.zxing.ResultPoint;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* This class attempts to decode a barcode from an image, not by scanning the whole image,
|
||||
* but by scanning subsets of the image. This is important when there may be multiple barcodes in
|
||||
* an image, and detecting a barcode may find parts of multiple barcode and fail to decode
|
||||
* (e.g. QR Codes). Instead this scans the four quadrants of the image -- and also the center
|
||||
* 'quadrant' to cover the case where a barcode is found in the center.
|
||||
*
|
||||
* @see GenericMultipleBarcodeReader
|
||||
*/
|
||||
public final class ByQuadrantReader implements Reader {
|
||||
|
||||
private final Reader delegate;
|
||||
|
||||
public ByQuadrantReader(Reader delegate) {
|
||||
this.delegate = delegate;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Result decode(BinaryBitmap image)
|
||||
throws NotFoundException, ChecksumException, FormatException {
|
||||
return decode(image, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Result decode(BinaryBitmap image, Map<DecodeHintType,?> hints)
|
||||
throws NotFoundException, ChecksumException, FormatException {
|
||||
|
||||
int width = image.getWidth();
|
||||
int height = image.getHeight();
|
||||
int halfWidth = width / 2;
|
||||
int halfHeight = height / 2;
|
||||
|
||||
try {
|
||||
// No need to call makeAbsolute as results will be relative to original top left here
|
||||
return delegate.decode(image.crop(0, 0, halfWidth, halfHeight), hints);
|
||||
} catch (NotFoundException re) {
|
||||
// continue
|
||||
}
|
||||
|
||||
try {
|
||||
Result result = delegate.decode(image.crop(halfWidth, 0, halfWidth, halfHeight), hints);
|
||||
makeAbsolute(result.getResultPoints(), halfWidth, 0);
|
||||
return result;
|
||||
} catch (NotFoundException re) {
|
||||
// continue
|
||||
}
|
||||
|
||||
try {
|
||||
Result result = delegate.decode(image.crop(0, halfHeight, halfWidth, halfHeight), hints);
|
||||
makeAbsolute(result.getResultPoints(), 0, halfHeight);
|
||||
return result;
|
||||
} catch (NotFoundException re) {
|
||||
// continue
|
||||
}
|
||||
|
||||
try {
|
||||
Result result = delegate.decode(image.crop(halfWidth, halfHeight, halfWidth, halfHeight), hints);
|
||||
makeAbsolute(result.getResultPoints(), halfWidth, halfHeight);
|
||||
return result;
|
||||
} catch (NotFoundException re) {
|
||||
// continue
|
||||
}
|
||||
|
||||
int quarterWidth = halfWidth / 2;
|
||||
int quarterHeight = halfHeight / 2;
|
||||
BinaryBitmap center = image.crop(quarterWidth, quarterHeight, halfWidth, halfHeight);
|
||||
Result result = delegate.decode(center, hints);
|
||||
makeAbsolute(result.getResultPoints(), quarterWidth, quarterHeight);
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset() {
|
||||
delegate.reset();
|
||||
}
|
||||
|
||||
private static void makeAbsolute(ResultPoint[] points, int leftOffset, int topOffset) {
|
||||
if (points != null) {
|
||||
for (int i = 0; i < points.length; i++) {
|
||||
ResultPoint relative = points[i];
|
||||
if (relative != null) {
|
||||
points[i] = new ResultPoint(relative.getX() + leftOffset, relative.getY() + topOffset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,182 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi;
|
||||
|
||||
import com.google.zxing.BinaryBitmap;
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.Reader;
|
||||
import com.google.zxing.ReaderException;
|
||||
import com.google.zxing.Result;
|
||||
import com.google.zxing.ResultPoint;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* <p>Attempts to locate multiple barcodes in an image by repeatedly decoding portion of the image.
|
||||
* After one barcode is found, the areas left, above, right and below the barcode's
|
||||
* {@link ResultPoint}s are scanned, recursively.</p>
|
||||
*
|
||||
* <p>A caller may want to also employ {@link ByQuadrantReader} when attempting to find multiple
|
||||
* 2D barcodes, like QR Codes, in an image, where the presence of multiple barcodes might prevent
|
||||
* detecting any one of them.</p>
|
||||
*
|
||||
* <p>That is, instead of passing a {@link Reader} a caller might pass
|
||||
* {@code new ByQuadrantReader(reader)}.</p>
|
||||
*
|
||||
* @author Sean Owen
|
||||
*/
|
||||
public final class GenericMultipleBarcodeReader implements MultipleBarcodeReader {
|
||||
|
||||
private static final int MIN_DIMENSION_TO_RECUR = 100;
|
||||
private static final int MAX_DEPTH = 4;
|
||||
|
||||
static final Result[] EMPTY_RESULT_ARRAY = new Result[0];
|
||||
|
||||
private final Reader delegate;
|
||||
|
||||
public GenericMultipleBarcodeReader(Reader delegate) {
|
||||
this.delegate = delegate;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Result[] decodeMultiple(BinaryBitmap image) throws NotFoundException {
|
||||
return decodeMultiple(image, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Result[] decodeMultiple(BinaryBitmap image, Map<DecodeHintType,?> hints)
|
||||
throws NotFoundException {
|
||||
List<Result> results = new ArrayList<>();
|
||||
doDecodeMultiple(image, hints, results, 0, 0, 0);
|
||||
if (results.isEmpty()) {
|
||||
throw NotFoundException.getNotFoundInstance();
|
||||
}
|
||||
return results.toArray(EMPTY_RESULT_ARRAY);
|
||||
}
|
||||
|
||||
private void doDecodeMultiple(BinaryBitmap image,
|
||||
Map<DecodeHintType,?> hints,
|
||||
List<Result> results,
|
||||
int xOffset,
|
||||
int yOffset,
|
||||
int currentDepth) {
|
||||
if (currentDepth > MAX_DEPTH) {
|
||||
return;
|
||||
}
|
||||
|
||||
Result result;
|
||||
try {
|
||||
result = delegate.decode(image, hints);
|
||||
} catch (ReaderException ignored) {
|
||||
return;
|
||||
}
|
||||
boolean alreadyFound = false;
|
||||
for (Result existingResult : results) {
|
||||
if (existingResult.getText().equals(result.getText())) {
|
||||
alreadyFound = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!alreadyFound) {
|
||||
results.add(translateResultPoints(result, xOffset, yOffset));
|
||||
}
|
||||
ResultPoint[] resultPoints = result.getResultPoints();
|
||||
if (resultPoints == null || resultPoints.length == 0) {
|
||||
return;
|
||||
}
|
||||
int width = image.getWidth();
|
||||
int height = image.getHeight();
|
||||
float minX = width;
|
||||
float minY = height;
|
||||
float maxX = 0.0f;
|
||||
float maxY = 0.0f;
|
||||
for (ResultPoint point : resultPoints) {
|
||||
if (point == null) {
|
||||
continue;
|
||||
}
|
||||
float x = point.getX();
|
||||
float y = point.getY();
|
||||
if (x < minX) {
|
||||
minX = x;
|
||||
}
|
||||
if (y < minY) {
|
||||
minY = y;
|
||||
}
|
||||
if (x > maxX) {
|
||||
maxX = x;
|
||||
}
|
||||
if (y > maxY) {
|
||||
maxY = y;
|
||||
}
|
||||
}
|
||||
|
||||
// Decode left of barcode
|
||||
if (minX > MIN_DIMENSION_TO_RECUR) {
|
||||
doDecodeMultiple(image.crop(0, 0, (int) minX, height),
|
||||
hints, results,
|
||||
xOffset, yOffset,
|
||||
currentDepth + 1);
|
||||
}
|
||||
// Decode above barcode
|
||||
if (minY > MIN_DIMENSION_TO_RECUR) {
|
||||
doDecodeMultiple(image.crop(0, 0, width, (int) minY),
|
||||
hints, results,
|
||||
xOffset, yOffset,
|
||||
currentDepth + 1);
|
||||
}
|
||||
// Decode right of barcode
|
||||
if (maxX < width - MIN_DIMENSION_TO_RECUR) {
|
||||
doDecodeMultiple(image.crop((int) maxX, 0, width - (int) maxX, height),
|
||||
hints, results,
|
||||
xOffset + (int) maxX, yOffset,
|
||||
currentDepth + 1);
|
||||
}
|
||||
// Decode below barcode
|
||||
if (maxY < height - MIN_DIMENSION_TO_RECUR) {
|
||||
doDecodeMultiple(image.crop(0, (int) maxY, width, height - (int) maxY),
|
||||
hints, results,
|
||||
xOffset, yOffset + (int) maxY,
|
||||
currentDepth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
private static Result translateResultPoints(Result result, int xOffset, int yOffset) {
|
||||
ResultPoint[] oldResultPoints = result.getResultPoints();
|
||||
if (oldResultPoints == null) {
|
||||
return result;
|
||||
}
|
||||
ResultPoint[] newResultPoints = new ResultPoint[oldResultPoints.length];
|
||||
for (int i = 0; i < oldResultPoints.length; i++) {
|
||||
ResultPoint oldPoint = oldResultPoints[i];
|
||||
if (oldPoint != null) {
|
||||
newResultPoints[i] = new ResultPoint(oldPoint.getX() + xOffset, oldPoint.getY() + yOffset);
|
||||
}
|
||||
}
|
||||
Result newResult = new Result(result.getText(),
|
||||
result.getRawBytes(),
|
||||
result.getNumBits(),
|
||||
newResultPoints,
|
||||
result.getBarcodeFormat(),
|
||||
result.getTimestamp());
|
||||
newResult.putAllMetadata(result.getResultMetadata());
|
||||
return newResult;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi;
|
||||
|
||||
import com.google.zxing.BinaryBitmap;
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.Result;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Implementation of this interface attempt to read several barcodes from one image.
|
||||
*
|
||||
* @see com.google.zxing.Reader
|
||||
* @author Sean Owen
|
||||
*/
|
||||
public interface MultipleBarcodeReader {
|
||||
|
||||
Result[] decodeMultiple(BinaryBitmap image) throws NotFoundException;
|
||||
|
||||
Result[] decodeMultiple(BinaryBitmap image,
|
||||
Map<DecodeHintType,?> hints) throws NotFoundException;
|
||||
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi.qrcode;
|
||||
|
||||
import com.google.zxing.BarcodeFormat;
|
||||
import com.google.zxing.BinaryBitmap;
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.ReaderException;
|
||||
import com.google.zxing.Result;
|
||||
import com.google.zxing.ResultMetadataType;
|
||||
import com.google.zxing.ResultPoint;
|
||||
import com.google.zxing.common.DecoderResult;
|
||||
import com.google.zxing.common.DetectorResult;
|
||||
import com.google.zxing.multi.MultipleBarcodeReader;
|
||||
import com.google.zxing.multi.qrcode.detector.MultiDetector;
|
||||
import com.google.zxing.qrcode.QRCodeReader;
|
||||
import com.google.zxing.qrcode.decoder.QRCodeDecoderMetaData;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
|
||||
/**
|
||||
* This implementation can detect and decode multiple QR Codes in an image.
|
||||
*
|
||||
* @author Sean Owen
|
||||
* @author Hannes Erven
|
||||
*/
|
||||
public final class QRCodeMultiReader extends QRCodeReader implements MultipleBarcodeReader {
|
||||
|
||||
private static final Result[] EMPTY_RESULT_ARRAY = new Result[0];
|
||||
private static final ResultPoint[] NO_POINTS = new ResultPoint[0];
|
||||
|
||||
@Override
|
||||
public Result[] decodeMultiple(BinaryBitmap image) throws NotFoundException {
|
||||
return decodeMultiple(image, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Result[] decodeMultiple(BinaryBitmap image, Map<DecodeHintType,?> hints) throws NotFoundException {
|
||||
List<Result> results = new ArrayList<>();
|
||||
DetectorResult[] detectorResults = new MultiDetector(image.getBlackMatrix()).detectMulti(hints);
|
||||
for (DetectorResult detectorResult : detectorResults) {
|
||||
try {
|
||||
DecoderResult decoderResult = getDecoder().decode(detectorResult.getBits(), hints);
|
||||
ResultPoint[] points = detectorResult.getPoints();
|
||||
// If the code was mirrored: swap the bottom-left and the top-right points.
|
||||
if (decoderResult.getOther() instanceof QRCodeDecoderMetaData) {
|
||||
((QRCodeDecoderMetaData) decoderResult.getOther()).applyMirroredCorrection(points);
|
||||
}
|
||||
Result result = new Result(decoderResult.getText(), decoderResult.getRawBytes(), points,
|
||||
BarcodeFormat.QR_CODE);
|
||||
List<byte[]> byteSegments = decoderResult.getByteSegments();
|
||||
if (byteSegments != null) {
|
||||
result.putMetadata(ResultMetadataType.BYTE_SEGMENTS, byteSegments);
|
||||
}
|
||||
String ecLevel = decoderResult.getECLevel();
|
||||
if (ecLevel != null) {
|
||||
result.putMetadata(ResultMetadataType.ERROR_CORRECTION_LEVEL, ecLevel);
|
||||
}
|
||||
if (decoderResult.hasStructuredAppend()) {
|
||||
result.putMetadata(ResultMetadataType.STRUCTURED_APPEND_SEQUENCE,
|
||||
decoderResult.getStructuredAppendSequenceNumber());
|
||||
result.putMetadata(ResultMetadataType.STRUCTURED_APPEND_PARITY,
|
||||
decoderResult.getStructuredAppendParity());
|
||||
}
|
||||
results.add(result);
|
||||
} catch (ReaderException re) {
|
||||
// ignore and continue
|
||||
}
|
||||
}
|
||||
if (results.isEmpty()) {
|
||||
return EMPTY_RESULT_ARRAY;
|
||||
} else {
|
||||
results = processStructuredAppend(results);
|
||||
return results.toArray(EMPTY_RESULT_ARRAY);
|
||||
}
|
||||
}
|
||||
|
||||
static List<Result> processStructuredAppend(List<Result> results) {
|
||||
List<Result> newResults = new ArrayList<>();
|
||||
List<Result> saResults = new ArrayList<>();
|
||||
for (Result result : results) {
|
||||
if (result.getResultMetadata().containsKey(ResultMetadataType.STRUCTURED_APPEND_SEQUENCE)) {
|
||||
saResults.add(result);
|
||||
} else {
|
||||
newResults.add(result);
|
||||
}
|
||||
}
|
||||
if (saResults.isEmpty()) {
|
||||
return results;
|
||||
}
|
||||
|
||||
// sort and concatenate the SA list items
|
||||
Collections.sort(saResults, new SAComparator());
|
||||
StringBuilder newText = new StringBuilder();
|
||||
ByteArrayOutputStream newRawBytes = new ByteArrayOutputStream();
|
||||
ByteArrayOutputStream newByteSegment = new ByteArrayOutputStream();
|
||||
for (Result saResult : saResults) {
|
||||
newText.append(saResult.getText());
|
||||
byte[] saBytes = saResult.getRawBytes();
|
||||
newRawBytes.write(saBytes, 0, saBytes.length);
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterable<byte[]> byteSegments =
|
||||
(Iterable<byte[]>) saResult.getResultMetadata().get(ResultMetadataType.BYTE_SEGMENTS);
|
||||
if (byteSegments != null) {
|
||||
for (byte[] segment : byteSegments) {
|
||||
newByteSegment.write(segment, 0, segment.length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Result newResult = new Result(newText.toString(), newRawBytes.toByteArray(), NO_POINTS, BarcodeFormat.QR_CODE);
|
||||
if (newByteSegment.size() > 0) {
|
||||
newResult.putMetadata(ResultMetadataType.BYTE_SEGMENTS, Collections.singletonList(newByteSegment.toByteArray()));
|
||||
}
|
||||
newResults.add(newResult);
|
||||
return newResults;
|
||||
}
|
||||
|
||||
private static final class SAComparator implements Comparator<Result>, Serializable {
|
||||
@Override
|
||||
public int compare(Result a, Result b) {
|
||||
int aNumber = (int) a.getResultMetadata().get(ResultMetadataType.STRUCTURED_APPEND_SEQUENCE);
|
||||
int bNumber = (int) b.getResultMetadata().get(ResultMetadataType.STRUCTURED_APPEND_SEQUENCE);
|
||||
return Integer.compare(aNumber, bNumber);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi.qrcode.detector;
|
||||
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.ReaderException;
|
||||
import com.google.zxing.ResultPointCallback;
|
||||
import com.google.zxing.common.BitMatrix;
|
||||
import com.google.zxing.common.DetectorResult;
|
||||
import com.google.zxing.qrcode.detector.Detector;
|
||||
import com.google.zxing.qrcode.detector.FinderPatternInfo;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* <p>Encapsulates logic that can detect one or more QR Codes in an image, even if the QR Code
|
||||
* is rotated or skewed, or partially obscured.</p>
|
||||
*
|
||||
* @author Sean Owen
|
||||
* @author Hannes Erven
|
||||
*/
|
||||
public final class MultiDetector extends Detector {
|
||||
|
||||
private static final DetectorResult[] EMPTY_DETECTOR_RESULTS = new DetectorResult[0];
|
||||
|
||||
public MultiDetector(BitMatrix image) {
|
||||
super(image);
|
||||
}
|
||||
|
||||
public DetectorResult[] detectMulti(Map<DecodeHintType,?> hints) throws NotFoundException {
|
||||
BitMatrix image = getImage();
|
||||
ResultPointCallback resultPointCallback =
|
||||
hints == null ? null : (ResultPointCallback) hints.get(DecodeHintType.NEED_RESULT_POINT_CALLBACK);
|
||||
MultiFinderPatternFinder finder = new MultiFinderPatternFinder(image, resultPointCallback);
|
||||
FinderPatternInfo[] infos = finder.findMulti(hints);
|
||||
|
||||
if (infos.length == 0) {
|
||||
throw NotFoundException.getNotFoundInstance();
|
||||
}
|
||||
|
||||
List<DetectorResult> result = new ArrayList<>();
|
||||
for (FinderPatternInfo info : infos) {
|
||||
try {
|
||||
result.add(processFinderPatternInfo(info));
|
||||
} catch (ReaderException e) {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
if (result.isEmpty()) {
|
||||
return EMPTY_DETECTOR_RESULTS;
|
||||
} else {
|
||||
return result.toArray(EMPTY_DETECTOR_RESULTS);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,290 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
package com.google.zxing.multi.qrcode.detector;
|
||||
|
||||
import com.google.zxing.DecodeHintType;
|
||||
import com.google.zxing.NotFoundException;
|
||||
import com.google.zxing.ResultPoint;
|
||||
import com.google.zxing.ResultPointCallback;
|
||||
import com.google.zxing.common.BitMatrix;
|
||||
import com.google.zxing.qrcode.detector.FinderPattern;
|
||||
import com.google.zxing.qrcode.detector.FinderPatternFinder;
|
||||
import com.google.zxing.qrcode.detector.FinderPatternInfo;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* <p>This class attempts to find finder patterns in a QR Code. Finder patterns are the square
|
||||
* markers at three corners of a QR Code.</p>
|
||||
*
|
||||
* <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.
|
||||
*
|
||||
* <p>In contrast to {@link FinderPatternFinder}, this class will return an array of all possible
|
||||
* QR code locations in the image.</p>
|
||||
*
|
||||
* <p>Use the TRY_HARDER hint to ask for a more thorough detection.</p>
|
||||
*
|
||||
* @author Sean Owen
|
||||
* @author Hannes Erven
|
||||
*/
|
||||
public final class MultiFinderPatternFinder extends FinderPatternFinder {
|
||||
|
||||
private static final FinderPatternInfo[] EMPTY_RESULT_ARRAY = new FinderPatternInfo[0];
|
||||
private static final FinderPattern[] EMPTY_FP_ARRAY = new FinderPattern[0];
|
||||
private static final FinderPattern[][] EMPTY_FP_2D_ARRAY = new FinderPattern[0][];
|
||||
|
||||
// TODO MIN_MODULE_COUNT and MAX_MODULE_COUNT would be great hints to ask the user for
|
||||
// since it limits the number of regions to decode
|
||||
|
||||
// max. legal count of modules per QR code edge (177)
|
||||
private static final float MAX_MODULE_COUNT_PER_EDGE = 180;
|
||||
// min. legal count per modules per QR code edge (11)
|
||||
private static final float MIN_MODULE_COUNT_PER_EDGE = 9;
|
||||
|
||||
/**
|
||||
* More or less arbitrary cutoff point for determining if two finder patterns might belong
|
||||
* to the same code if they differ less than DIFF_MODSIZE_CUTOFF_PERCENT percent in their
|
||||
* estimated modules sizes.
|
||||
*/
|
||||
private static final float DIFF_MODSIZE_CUTOFF_PERCENT = 0.05f;
|
||||
|
||||
/**
|
||||
* More or less arbitrary cutoff point for determining if two finder patterns might belong
|
||||
* to the same code if they differ less than DIFF_MODSIZE_CUTOFF pixels/module in their
|
||||
* estimated modules sizes.
|
||||
*/
|
||||
private static final float DIFF_MODSIZE_CUTOFF = 0.5f;
|
||||
|
||||
|
||||
/**
|
||||
* A comparator that orders FinderPatterns by their estimated module size.
|
||||
*/
|
||||
private static final class ModuleSizeComparator implements Comparator<FinderPattern>, Serializable {
|
||||
@Override
|
||||
public int compare(FinderPattern center1, FinderPattern center2) {
|
||||
float value = center2.getEstimatedModuleSize() - center1.getEstimatedModuleSize();
|
||||
return value < 0.0 ? -1 : value > 0.0 ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
public MultiFinderPatternFinder(BitMatrix image, ResultPointCallback resultPointCallback) {
|
||||
super(image, resultPointCallback);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the 3 best {@link FinderPattern}s from our list of candidates. The "best" are
|
||||
* those that have been detected at least 2 times, and whose module
|
||||
* size differs from the average among those patterns the least
|
||||
* @throws NotFoundException if 3 such finder patterns do not exist
|
||||
*/
|
||||
private FinderPattern[][] selectMultipleBestPatterns() throws NotFoundException {
|
||||
List<FinderPattern> possibleCenters = new ArrayList<>();
|
||||
for (FinderPattern fp : getPossibleCenters()) {
|
||||
if (fp.getCount() >= 2) {
|
||||
possibleCenters.add(fp);
|
||||
}
|
||||
}
|
||||
int size = possibleCenters.size();
|
||||
|
||||
if (size < 3) {
|
||||
// Couldn't find enough finder patterns
|
||||
throw NotFoundException.getNotFoundInstance();
|
||||
}
|
||||
|
||||
/*
|
||||
* Begin HE modifications to safely detect multiple codes of equal size
|
||||
*/
|
||||
if (size == 3) {
|
||||
return new FinderPattern[][] { possibleCenters.toArray(EMPTY_FP_ARRAY) };
|
||||
}
|
||||
|
||||
// Sort by estimated module size to speed up the upcoming checks
|
||||
Collections.sort(possibleCenters, new ModuleSizeComparator());
|
||||
|
||||
/*
|
||||
* Now lets start: build a list of tuples of three finder locations that
|
||||
* - feature similar module sizes
|
||||
* - are placed in a distance so the estimated module count is within the QR specification
|
||||
* - have similar distance between upper left/right and left top/bottom finder patterns
|
||||
* - form a triangle with 90° angle (checked by comparing top right/bottom left distance
|
||||
* with pythagoras)
|
||||
*
|
||||
* Note: we allow each point to be used for more than one code region: this might seem
|
||||
* counterintuitive at first, but the performance penalty is not that big. At this point,
|
||||
* we cannot make a good quality decision whether the three finders actually represent
|
||||
* a QR code, or are just by chance laid out so it looks like there might be a QR code there.
|
||||
* So, if the layout seems right, lets have the decoder try to decode.
|
||||
*/
|
||||
|
||||
List<FinderPattern[]> results = new ArrayList<>(); // holder for the results
|
||||
|
||||
for (int i1 = 0; i1 < (size - 2); i1++) {
|
||||
FinderPattern p1 = possibleCenters.get(i1);
|
||||
if (p1 == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
for (int i2 = i1 + 1; i2 < (size - 1); i2++) {
|
||||
FinderPattern p2 = possibleCenters.get(i2);
|
||||
if (p2 == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Compare the expected module sizes; if they are really off, skip
|
||||
float vModSize12 = (p1.getEstimatedModuleSize() - p2.getEstimatedModuleSize()) /
|
||||
Math.min(p1.getEstimatedModuleSize(), p2.getEstimatedModuleSize());
|
||||
float vModSize12A = Math.abs(p1.getEstimatedModuleSize() - p2.getEstimatedModuleSize());
|
||||
if (vModSize12A > DIFF_MODSIZE_CUTOFF && vModSize12 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
|
||||
// break, since elements are ordered by the module size deviation there cannot be
|
||||
// any more interesting elements for the given p1.
|
||||
break;
|
||||
}
|
||||
|
||||
for (int i3 = i2 + 1; i3 < size; i3++) {
|
||||
FinderPattern p3 = possibleCenters.get(i3);
|
||||
if (p3 == null) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Compare the expected module sizes; if they are really off, skip
|
||||
float vModSize23 = (p2.getEstimatedModuleSize() - p3.getEstimatedModuleSize()) /
|
||||
Math.min(p2.getEstimatedModuleSize(), p3.getEstimatedModuleSize());
|
||||
float vModSize23A = Math.abs(p2.getEstimatedModuleSize() - p3.getEstimatedModuleSize());
|
||||
if (vModSize23A > DIFF_MODSIZE_CUTOFF && vModSize23 >= DIFF_MODSIZE_CUTOFF_PERCENT) {
|
||||
// break, since elements are ordered by the module size deviation there cannot be
|
||||
// any more interesting elements for the given p1.
|
||||
break;
|
||||
}
|
||||
|
||||
FinderPattern[] test = {p1, p2, p3};
|
||||
ResultPoint.orderBestPatterns(test);
|
||||
|
||||
// Calculate the distances: a = topleft-bottomleft, b=topleft-topright, c = diagonal
|
||||
FinderPatternInfo info = new FinderPatternInfo(test);
|
||||
float dA = ResultPoint.distance(info.getTopLeft(), info.getBottomLeft());
|
||||
float dC = ResultPoint.distance(info.getTopRight(), info.getBottomLeft());
|
||||
float dB = ResultPoint.distance(info.getTopLeft(), info.getTopRight());
|
||||
|
||||
// Check the sizes
|
||||
float estimatedModuleCount = (dA + dB) / (p1.getEstimatedModuleSize() * 2.0f);
|
||||
if (estimatedModuleCount > MAX_MODULE_COUNT_PER_EDGE ||
|
||||
estimatedModuleCount < MIN_MODULE_COUNT_PER_EDGE) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Calculate the difference of the edge lengths in percent
|
||||
float vABBC = Math.abs((dA - dB) / Math.min(dA, dB));
|
||||
if (vABBC >= 0.1f) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Calculate the diagonal length by assuming a 90° angle at topleft
|
||||
float dCpy = (float) Math.sqrt((double) dA * dA + (double) dB * dB);
|
||||
// Compare to the real distance in %
|
||||
float vPyC = Math.abs((dC - dCpy) / Math.min(dC, dCpy));
|
||||
|
||||
if (vPyC >= 0.1f) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// All tests passed!
|
||||
results.add(test);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!results.isEmpty()) {
|
||||
return results.toArray(EMPTY_FP_2D_ARRAY);
|
||||
}
|
||||
|
||||
// Nothing found!
|
||||
throw NotFoundException.getNotFoundInstance();
|
||||
}
|
||||
|
||||
public FinderPatternInfo[] findMulti(Map<DecodeHintType,?> hints) throws NotFoundException {
|
||||
boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
|
||||
BitMatrix image = getImage();
|
||||
int maxI = image.getHeight();
|
||||
int maxJ = image.getWidth();
|
||||
// We are looking for black/white/black/white/black modules in
|
||||
// 1:1:3:1:1 ratio; this tracks the number of such modules seen so far
|
||||
|
||||
// Let's assume that the maximum version QR Code we support takes up 1/4 the height of the
|
||||
// image, and then account for the center being 3 modules in size. This gives the smallest
|
||||
// number of pixels the center could be, so skip this often. When trying harder, look for all
|
||||
// QR versions regardless of how dense they are.
|
||||
int iSkip = (3 * maxI) / (4 * MAX_MODULES);
|
||||
if (iSkip < MIN_SKIP || tryHarder) {
|
||||
iSkip = MIN_SKIP;
|
||||
}
|
||||
|
||||
int[] stateCount = new int[5];
|
||||
for (int i = iSkip - 1; i < maxI; i += iSkip) {
|
||||
// Get a row of black/white values
|
||||
doClearCounts(stateCount);
|
||||
int currentState = 0;
|
||||
for (int j = 0; j < maxJ; j++) {
|
||||
if (image.get(j, i)) {
|
||||
// Black pixel
|
||||
if ((currentState & 1) == 1) { // Counting white pixels
|
||||
currentState++;
|
||||
}
|
||||
stateCount[currentState]++;
|
||||
} else { // White pixel
|
||||
if ((currentState & 1) == 0) { // Counting black pixels
|
||||
if (currentState == 4) { // A winner?
|
||||
if (foundPatternCross(stateCount) && handlePossibleCenter(stateCount, i, j)) { // Yes
|
||||
// Clear state to start looking again
|
||||
currentState = 0;
|
||||
doClearCounts(stateCount);
|
||||
} else { // No, shift counts back by two
|
||||
doShiftCounts2(stateCount);
|
||||
currentState = 3;
|
||||
}
|
||||
} else {
|
||||
stateCount[++currentState]++;
|
||||
}
|
||||
} else { // Counting white pixels
|
||||
stateCount[currentState]++;
|
||||
}
|
||||
}
|
||||
} // for j=...
|
||||
|
||||
if (foundPatternCross(stateCount)) {
|
||||
handlePossibleCenter(stateCount, i, maxJ);
|
||||
}
|
||||
} // for i=iSkip-1 ...
|
||||
FinderPattern[][] patternInfo = selectMultipleBestPatterns();
|
||||
List<FinderPatternInfo> result = new ArrayList<>();
|
||||
for (FinderPattern[] pattern : patternInfo) {
|
||||
ResultPoint.orderBestPatterns(pattern);
|
||||
result.add(new FinderPatternInfo(pattern));
|
||||
}
|
||||
|
||||
if (result.isEmpty()) {
|
||||
return EMPTY_RESULT_ARRAY;
|
||||
} else {
|
||||
return result.toArray(EMPTY_RESULT_ARRAY);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user