/**
* @return the 3 best {@link FinderPattern}s from our list of candidates. The "best" are those
* that have been detected at least {@link #CENTER_QUORUM} 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[][] selectBestPatterns() throws NotFoundException {
Vector possibleCenters = getPossibleCenters();
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[][] {
new FinderPattern[] {
(FinderPattern) possibleCenters.elementAt(0),
(FinderPattern) possibleCenters.elementAt(1),
(FinderPattern) possibleCenters.elementAt(2)
}
};
}
// Sort by estimated module size to speed up the upcoming checks
Collections.insertionSort(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 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.
*/
Vector results = new Vector(); // holder for the results
for (int i1 = 0; i1 < (size - 2); i1++) {
FinderPattern p1 = (FinderPattern) possibleCenters.elementAt(i1);
if (p1 == null) {
continue;
}
for (int i2 = i1 + 1; i2 < (size - 1); i2++) {
FinderPattern p2 = (FinderPattern) possibleCenters.elementAt(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 = (FinderPattern) possibleCenters.elementAt(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;
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.addElement(test);
} // end iterate p3
} // end iterate p2
} // end iterate p1
if (!results.isEmpty()) {
FinderPattern[][] resultArray = new FinderPattern[results.size()][];
for (int i = 0; i < results.size(); i++) {
resultArray[i] = (FinderPattern[]) results.elementAt(i);
}
return resultArray;
}
// Nothing found!
throw NotFoundException.getNotFoundInstance();
}
