mirror of
https://github.com/zxing/zxing.git
synced 2025-03-05 20:48:51 -08:00
7616c4d06d
git-svn-id: https://zxing.googlecode.com/svn/trunk@2558 59b500cc-1b3d-0410-9834-0bbf25fbcc57
351 lines
12 KiB
C#
Executable file
351 lines
12 KiB
C#
Executable file
using System;
|
|
using System.Collections.Generic;
|
|
|
|
/*
|
|
* 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.multi.qrcode.detector
|
|
{
|
|
|
|
using DecodeHintType = com.google.zxing.DecodeHintType;
|
|
using NotFoundException = com.google.zxing.NotFoundException;
|
|
using ResultPoint = com.google.zxing.ResultPoint;
|
|
using ResultPointCallback = com.google.zxing.ResultPointCallback;
|
|
using BitMatrix = com.google.zxing.common.BitMatrix;
|
|
using FinderPattern = com.google.zxing.qrcode.detector.FinderPattern;
|
|
using FinderPatternFinder = com.google.zxing.qrcode.detector.FinderPatternFinder;
|
|
using FinderPatternInfo = com.google.zxing.qrcode.detector.FinderPatternInfo;
|
|
|
|
|
|
/// <summary>
|
|
/// <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 <seealso cref="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
|
|
/// </summary>
|
|
internal sealed class MultiFinderPatternFinder : com.google.zxing.qrcode.detector.FinderPatternFinder
|
|
{
|
|
|
|
private static readonly FinderPatternInfo[] EMPTY_RESULT_ARRAY = new FinderPatternInfo[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 const float MAX_MODULE_COUNT_PER_EDGE = 180;
|
|
// min. legal count per modules per QR code edge (11)
|
|
private const float MIN_MODULE_COUNT_PER_EDGE = 9;
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
private const float DIFF_MODSIZE_CUTOFF_PERCENT = 0.05f;
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
private const float DIFF_MODSIZE_CUTOFF = 0.5f;
|
|
|
|
|
|
/// <summary>
|
|
/// A comparator that orders FinderPatterns by their estimated module size.
|
|
/// </summary>
|
|
[Serializable]
|
|
private sealed class ModuleSizeComparator : IComparer<com.google.zxing.qrcode.detector.FinderPattern>
|
|
{
|
|
public int Compare(FinderPattern center1, FinderPattern center2)
|
|
{
|
|
float value = center2.EstimatedModuleSize - center1.EstimatedModuleSize;
|
|
return value < 0.0 ? - 1 : value > 0.0 ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// <p>Creates a finder that will search the image for three finder patterns.</p>
|
|
/// </summary>
|
|
/// <param name="image"> image to search </param>
|
|
internal MultiFinderPatternFinder(BitMatrix image) : base(image)
|
|
{
|
|
}
|
|
|
|
internal MultiFinderPatternFinder(BitMatrix image, ResultPointCallback resultPointCallback) : base(image, resultPointCallback)
|
|
{
|
|
}
|
|
|
|
/// <returns> the 3 best <seealso cref="FinderPattern"/>s from our list of candidates. The "best" are
|
|
/// those that have been detected at least <seealso cref="#CENTER_QUORUM"/> times, and whose module
|
|
/// size differs from the average among those patterns the least </returns>
|
|
/// <exception cref="NotFoundException"> if 3 such finder patterns do not exist </exception>
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: private com.google.zxing.qrcode.detector.FinderPattern[][] selectMutipleBestPatterns() throws com.google.zxing.NotFoundException
|
|
private FinderPattern[][] selectMutipleBestPatterns()
|
|
{
|
|
List<FinderPattern> possibleCenters = PossibleCenters;
|
|
int size = possibleCenters.Count;
|
|
|
|
if (size < 3)
|
|
{
|
|
// Couldn't find enough finder patterns
|
|
throw NotFoundException.NotFoundInstance;
|
|
}
|
|
|
|
/*
|
|
* Begin HE modifications to safely detect multiple codes of equal size
|
|
*/
|
|
if (size == 3)
|
|
{
|
|
return new FinderPattern[][]{new FinderPattern[]{possibleCenters[0], possibleCenters[1], possibleCenters[2]}};
|
|
}
|
|
|
|
// Sort by estimated module size to speed up the upcoming checks
|
|
possibleCenters.Sort(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 layouted 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 List<FinderPattern[]>(); // holder for the results
|
|
|
|
for (int i1 = 0; i1 < (size - 2); i1++)
|
|
{
|
|
FinderPattern p1 = possibleCenters[i1];
|
|
if (p1 == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int i2 = i1 + 1; i2 < (size - 1); i2++)
|
|
{
|
|
FinderPattern p2 = possibleCenters[i2];
|
|
if (p2 == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Compare the expected module sizes; if they are really off, skip
|
|
float vModSize12 = (p1.EstimatedModuleSize - p2.EstimatedModuleSize) / Math.Min(p1.EstimatedModuleSize, p2.EstimatedModuleSize);
|
|
float vModSize12A = Math.Abs(p1.EstimatedModuleSize - p2.EstimatedModuleSize);
|
|
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[i3];
|
|
if (p3 == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Compare the expected module sizes; if they are really off, skip
|
|
float vModSize23 = (p2.EstimatedModuleSize - p3.EstimatedModuleSize) / Math.Min(p2.EstimatedModuleSize, p3.EstimatedModuleSize);
|
|
float vModSize23A = Math.Abs(p2.EstimatedModuleSize - p3.EstimatedModuleSize);
|
|
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.TopLeft, info.BottomLeft);
|
|
float dC = ResultPoint.distance(info.TopRight, info.BottomLeft);
|
|
float dB = ResultPoint.distance(info.TopLeft, info.TopRight);
|
|
|
|
// Check the sizes
|
|
float estimatedModuleCount = (dA + dB) / (p1.EstimatedModuleSize * 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(dA * dA + 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);
|
|
} // end iterate p3
|
|
} // end iterate p2
|
|
} // end iterate p1
|
|
|
|
if (results.Count > 0)
|
|
{
|
|
return results.ToArray();
|
|
}
|
|
|
|
// Nothing found!
|
|
throw NotFoundException.NotFoundInstance;
|
|
}
|
|
|
|
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
|
|
//ORIGINAL LINE: public com.google.zxing.qrcode.detector.FinderPatternInfo[] findMulti(java.util.Map<com.google.zxing.DecodeHintType,?> hints) throws com.google.zxing.NotFoundException
|
|
public FinderPatternInfo[] findMulti(IDictionary<DecodeHintType, object> hints)
|
|
{
|
|
bool tryHarder = hints != null && hints.ContainsKey(DecodeHintType.TRY_HARDER);
|
|
BitMatrix image = Image;
|
|
int maxI = image.Height;
|
|
int maxJ = image.Width;
|
|
// 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 = (int)(maxI / (MAX_MODULES * 4.0f) * 3);
|
|
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
|
|
stateCount[0] = 0;
|
|
stateCount[1] = 0;
|
|
stateCount[2] = 0;
|
|
stateCount[3] = 0;
|
|
stateCount[4] = 0;
|
|
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]++;
|
|
} // White pixel
|
|
else
|
|
{
|
|
if ((currentState & 1) == 0) // Counting black pixels
|
|
{
|
|
if (currentState == 4) // A winner?
|
|
{
|
|
if (foundPatternCross(stateCount)) // Yes
|
|
{
|
|
bool confirmed = handlePossibleCenter(stateCount, i, j);
|
|
if (!confirmed)
|
|
{
|
|
do // Advance to next black pixel
|
|
{
|
|
j++;
|
|
} while (j < maxJ && !image.get(j, i));
|
|
j--; // back up to that last white pixel
|
|
}
|
|
// Clear state to start looking again
|
|
currentState = 0;
|
|
stateCount[0] = 0;
|
|
stateCount[1] = 0;
|
|
stateCount[2] = 0;
|
|
stateCount[3] = 0;
|
|
stateCount[4] = 0;
|
|
} // No, shift counts back by two
|
|
else
|
|
{
|
|
stateCount[0] = stateCount[2];
|
|
stateCount[1] = stateCount[3];
|
|
stateCount[2] = stateCount[4];
|
|
stateCount[3] = 1;
|
|
stateCount[4] = 0;
|
|
currentState = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stateCount[++currentState]++;
|
|
}
|
|
} // Counting white pixels
|
|
else
|
|
{
|
|
stateCount[currentState]++;
|
|
}
|
|
}
|
|
} // for j=...
|
|
|
|
if (foundPatternCross(stateCount))
|
|
{
|
|
handlePossibleCenter(stateCount, i, maxJ);
|
|
} // end if foundPatternCross
|
|
} // for i=iSkip-1 ...
|
|
FinderPattern[][] patternInfo = selectMutipleBestPatterns();
|
|
List<FinderPatternInfo> result = new List<FinderPatternInfo>();
|
|
foreach (FinderPattern[] pattern in patternInfo)
|
|
{
|
|
ResultPoint.orderBestPatterns(pattern);
|
|
result.Add(new FinderPatternInfo(pattern));
|
|
}
|
|
|
|
if (result.Count == 0)
|
|
{
|
|
return EMPTY_RESULT_ARRAY;
|
|
}
|
|
else
|
|
{
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
} |